megaco_encoder(3)



megaco_encoder(3erl)       Erlang Module Definition       megaco_encoder(3erl)

NAME
       megaco_encoder - Megaco encoder behaviour.

DESCRIPTION
       The  following functions should be exported from a megaco_encoder call-
       back module:

DATA TYPES
   Note:
       Note that the actual definition of (some of) these  records  depend  on
       the  megaco protocol version used. For instance, the 'TransactionReply'
       record has two more fields in version 3, so a simple erlang type  defi-
       nition cannot be made here.

       protocol_version() = integer()
       segment_no()       = integer()
       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'{}
       command_request() = #'CommandRequest'{}
       error_desc()   = #'ErrorDescriptor'{}

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, Mes-
       sage} | 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 | Er-
       ror

              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_imple-
              mented.

       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!

Ericsson AB                      megaco 3.19.1            megaco_encoder(3erl)

Man(1) output converted with man2html
list of all man pages