/lss_parse_utils/src/lss_parse_utils.erl

https://github.com/ashneyderman/lss · Erlang · 73 lines · 26 code · 8 blank · 39 comment · 0 complexity · fa84d96c6643954bded26072060f6f00 MD5 · raw file 

    

  1. % @author Alex Shneyderman <a.shneyderman@gmail.com>
    2. 

  2. % @copyright (C) 2011, Alex Shneyderman
    3. 

  3. % @since May 26, 2011
    4. 

  4. 

  5. %-------------------------------------------------------------------- 
    6. 

  6. % @doc
    7. 

  7. % Helper module that contains routines that parse a binary stream 
    8. 

  8. % and produce messages (tuples) to be consumed by LSS. The operation
    9. 

  9. % can work in reverse as well - given a tuple a binary could be 
    10. 

  10. % produced.
    11. 

  11. % @end
    12. 

  12. %--------------------------------------------------------------------
    13. 

  13. -module(lss_parse_utils).
    14. 

  14. 

  15. -export([parse_messages/1,create_messages/1]).
    16. 

  16. -define(START_MSG_MARKER,<<16#FF,16#FF,16#FF,16#FF,16#FF,16#FF,16#FF,16#FF>>).
    17. 

  17. 

  18. %-------------------------------------------------------------------- 
    19. 

  19. % @doc 
    20. 

  20. % Parsing messages out of the chunks of binaries that arrived on the socket.
    21. 

  21. % The function returns a list of messages taht were parsed and left over binary 
    22. 

  22. % chunks.
    23. 

  23. %
    24. 

  24. % @spec parse_messages(Binaries) -> { Messages } |
    25. 

  25. %                                   { Messages, LeftOver }
    26. 

  26. %       Binaries = [binary()]
    27. 

  27. %       Messages = [term()]
    28. 

  28. %       LeftOver = binary()
    29. 

  29. %
    30. 

  30. % @end
    31. 

  31. %--------------------------------------------------------------------
    32. 

  32. parse_messages( Binaries ) ->
    33. 

  33.     consume_binary( list_to_binary( lists:reverse( Binaries ) ) ).
    34. 

  34. 

  35. %-------------------------------------------------------------------- 
    36. 

  36. % @doc 
    37. 

  37. % Takes a term or a list of terms and converts them into a list 
    38. 

  38. % of binaries that can be sent out via the wire. Terms are separates
    39. 

  39. % by the START_MSG_MARKER, which is appended to the end of each term.
    40. 

  40. %
    41. 

  41. % @spec create_messages(Term|Terms) -> { Messages } 
    42. 

  42. %       Term = term()
    43. 

  43. %       Terms = [term()]
    44. 

  44. %       Messages = [binary()]
    45. 

  45. % @end
    46. 

  46. %--------------------------------------------------------------------
    47. 

  47. create_messages([]) -> [];
    48. 

  48. create_messages([Term|Terms]) -> lists:append( create_messages(Term), create_messages(Terms) );
    49. 

  49. create_messages(Term) when is_tuple(Term)-> [term_to_binary(Term), ?START_MSG_MARKER].
    50. 

  50. 

  51. % module functions
    52. 

  52. %--------------------------------------------------------------------
    53. 

  53. consume_binary( <<>> ) -> { [] };
    54. 

  54. consume_binary( Binary ) ->
    55. 

  55.     BinChunks = binary:split( Binary, ?START_MSG_MARKER, [ global ] ),
    56. 

  56.     Messages = produce_msgs( [], BinChunks ),
    57. 

  57.     case lists:last( BinChunks ) of
    58. 

  58.         <<>> ->
    59. 

  59.             { Messages };
    60. 

  60.         Other ->
    61. 

  61.             { Messages, Other }
    62. 

  62.     end.
    63. 

  63. 

  64. produce_msgs( SoFar, [] ) -> SoFar;
    65. 

  65. produce_msgs( SoFar, [BinTerm,<<>> | Tail] ) -> % <<>> stands for the message separator, so BinTerm represents a full message
    66. 

  66.     case produce_msg( BinTerm ) of
    67. 

  67.         undefined -> produce_msgs( SoFar, Tail );
    68. 

  68.         Term -> produce_msgs( lists:append( SoFar, [Term] ), Tail ) 
    69. 

  69.     end.
    70. 

  70. 

  71. 

  72. produce_msg( <<>> ) -> undefined;
    73. 

  73. produce_msg( BinTerm ) -> binary_to_term( BinTerm ).
    74.