NAME

       megaco_encoder - Megaco encoder behaviour.

DESCRIPTION

       The following functions should be exported from a megaco_encoder callback module:

DATA TYPES

       megaco_message() = #'MegacoMessage{}'
       transaction() = {transactionRequest,     transaction_request()}      |
                       {transactionPending,     transaction_reply()}        |
                       {transactionReply,       transaction_pending()}      |
                       {transactionResponseAck, transaction_response_ack()} |
                       {segmentReply,           segment_reply()}
       transaction_request() = #'TransactionRequest'{}
       transaction_pending() = #'TransactionPending'{}
       transaction_reply() = #'TransactionReply'{}
       transaction_response_ack() = [transaction_ack()]
       transaction_ack() = #'TransactionAck'{}
       segment_reply() = #'SegmentReply'{}
       action_request() = #'ActionRequest'{}
       action_reply() = #'ActionReply'{}

EXPORTS

       Module:encode_message(EncodingConfig, Version, Message) -> {ok, Bin} | Error

              Types:

                 EncodingConfig = list()
                 Version = integer()
                 Message = megaco_message()
                 Bin = binary()
                 Error = term()

              Encode a megaco message.

       Module:decode_message(EncodingConfig, Version, Bin) -> {ok, Message} | Error

              Types:

                 EncodingConfig = list()
                 Version = integer() | dynamic
                 Message = megaco_message()
                 Bin = binary()
                 Error = term()

              Decode a megaco message.

              Note  that if the Version argument is dynamic, the decoder should try to figure out
              the actual version from the message itself and then use the  proper  decoder,  e.g.
              version 1.
              If  on the other hand the Version argument is an integer, it means that this is the
              expected version of the message and the decoder for that version should be used.

       Module:decode_mini_message(EncodingConfig, Version, Bin) -> {ok, Message} | Error

              Types:

                 EncodingConfig = list()
                 Version = integer() | dynamic
                 Message = megaco_message()
                 Bin = binary()
                 Error = term()

              Perform a minimal decode of a megaco message.

              The purpose of this function is to  do  a  minimal  decode  of  Megaco  message.  A
              successfull  result  is  a  'MegacoMessage'  in which only version and mid has been
              initiated.  This  function  is  used  by  the  megaco_messenger  module  when   the
              decode_message/3  function  fails  to figure out the mid (the actual sender) of the
              message.

              Note again that a successfull decode only returns a partially initiated message.

       Module:encode_transaction(EncodingConfig, Version, Transaction) -> OK | Error

              Types:

                 EncodingConfig = list()
                 Version = integer()
                 Transaction = transaction()
                 OK = {ok, Bin}
                 Bin = binary()
                 Error = {error, Reason}
                 Reason = not_implemented | OtherReason
                 OtherReason = term()

              Encode a megaco transaction. If this, for whatever reason, is  not  supported,  the
              function should return the error reason not_implemented.

              This  functionality  is  used  both  when  the  transaction  sender is used and for
              segmentation. So, for either  of  those  to  work,  this  function  must  be  fully
              supported!

       Module:encode_action_requests(EncodingConfig, Version, ARs) -> OK | Error

              Types:

                 EncodingConfig = list()
                 Version = integer()
                 ARs = action_requests()
                 action_requests() = [action_request()]
                 OK = {ok, Bin}
                 Bin = binary()
                 Error = {error, Reason}
                 Reason = not_implemented | OtherReason
                 OtherReason = term()

              Encode  megaco  action  requests.  This  function is called when the user calls the
              function encode_actions/3. If that function is never used or if  the  codec  cannot
              support  this  (the  encoding of individual actions), then return with error reason
              not_implemented.

       Module:encode_action_reply(EncodingConfig, Version, AR) -> OK | Error

              Types:

                 EncodingConfig = list()
                 Version = integer()
                 AR = action_reply()
                 OK = {ok, Bin}
                 Bin = binary()
                 Error = {error, Reason}
                 Reason = not_implemented | OtherReason
                 OtherReason = term()

              Encode a megaco action reply. If this, for whatever reason, is not  supported,  the
              function should return the error reason not_implemented.

              This  function is used when segmentation has been configured. So, for this to work,
              this function must be fully supported!