bionic (3) megaco_encoder.3erl.gz

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!