megaco_session_externalizer.erl

一个Megaco实现源代码

                                  timeNotation = Time},
                 State) ->
    #'MegacoMessage_ObservedEvent'{name         = tr_EventName(Name, State),
                                   id           = tr_opt_StreamID(Id, State),
                                   eventParList = [tr_EventParameter(P, Name, State) || P <- Parms],
                                   timeNotation = tr_opt_TimeNotation(Time, State)}.

tr_EventName(Name, State) ->
    tr_PkgdName(Name, State).

tr_EventParameter(#'EventParameter'{eventParameterName = ParName,
                                    value              = Value,
                                    extraInfo          = Extra},
                  EventName,
                  State) ->
    #'MegacoMessage_EventParameter'{eventParameterName = tr_Name(ParName, State),
                                    eventParameterValue= tr_Value(Value, State),
                                    extraInfo          = tr_opt_extraInfo(Extra, State)}.

tr_ServiceChangeRequest(#'ServiceChangeRequest'{terminationID      = IdList,
                                                serviceChangeParms = Parms},
                        State) ->
    #'MegacoMessage_ServiceChangeRequest'{termIdList         = [tr_TerminationID(Id, State) || Id <- IdList],
                                          serviceChangeParms = tr_ServiceChangeParm(Parms, State)}.

tr_ServiceChangeReply(#'ServiceChangeReply'{terminationID       = IdList,
                                            serviceChangeResult = Res},
                      State) ->
    #'MegacoMessage_ServiceChangeReply'{termIdList = [tr_TerminationID(Id, State) || Id <- IdList],
                                        serviceChangeResult = tr_ServiceChangeResult(Res, State)}.

tr_ServiceChangeResult({Tag, Val}, State) ->
    case Tag of
	errorDescriptor       -> 
	    #'MegacoMessage_ServiceChangeResultUnion'{label = 'ServiceChangeResultChoice_errorDescriptor',
						      value = tr_ErrorDescriptor(Val, State)};
	serviceChangeResParms -> 
	    #'MegacoMessage_ServiceChangeResultUnion'{label = 'ServiceChangeResultChoice_serviceChangeResParms',
						      value = tr_ServiceChangeResParm(Val, State)}
	end.

tr_TerminationID(#'TerminationID'{wildcard = Wild, id  = Id}, State) ->
    Val = #'MegacoMessage_BinaryTerminationId'{wildcard = Wild,
                                               id       = Id},
    #'MegacoMessage_TerminationIdUnion'{label = 'Encoding_binary',
                                        value = Val};
tr_TerminationID(#megaco_term_id{contains_wildcards = IsWild, id = Id}, State) ->
    Val = #'MegacoMessage_TextTerminationId'{containsWildcards = tr_bool(IsWild, State),
                                             id                = Id},
    #'MegacoMessage_TerminationIdUnion'{label = 'Encoding_text',
                                        value = Val}.

tr_opt_bool(asn1_NOVALUE, State) ->
    #'MegacoMessage_OptBoolean'{label = false};
tr_opt_bool(Bool, State) ->
    #'MegacoMessage_OptBoolean'{label = true,
                                value = tr_bool(Bool, State)}.

tr_bool(Bool, State)  -> Bool.

tr_MediaDescriptor(#'MediaDescriptor'{termStateDescr = TermState,
                                      streams        = Streams},
                   State) ->
    #'MegacoMessage_MediaDescriptor'{termStateDescr = tr_opt_TerminationStateDescriptor(TermState, State),
                                     streams        = tr_opt_streams(Streams, State)}.

tr_opt_streams(asn1_NOVALUE, State) ->
    #'MegacoMessage_OptStreamsUnion'{label = false};
tr_opt_streams(Val, State) ->
    #'MegacoMessage_OptStreamsUnion'{label = true, value = tr_streams(Val, State)}.

tr_streams({Tag, Val}, State) ->
    case Tag of
        oneStream   ->
            #'MegacoMessage_StreamsUnion'{label = 'OptStreamsChoice_oneStream',
					  value = tr_StreamParms(Val, State)};
        multiStream ->
            #'MegacoMessage_StreamsUnion'{label = 'OptStreamsChoice_multiStream',
					  value = [tr_StreamDescriptor(SD, State) || SD <- Val]}
    end.

tr_StreamParms(#'StreamParms'{localControlDescriptor = Control,
                              localDescriptor        = Local,
                              remoteDescriptor       = Remote},
               State) ->
    #'MegacoMessage_StreamParms'{localControlDescriptor = tr_opt_LocalControlDescriptor(Control, State),
                                 localDescriptor        = tr_opt_LocalRemoteDescriptor(Local, State),
                                 remoteDescriptor       = tr_opt_LocalRemoteDescriptor(Remote, State)}.

tr_StreamDescriptor(#'StreamDescriptor'{streamID    = Id,
                                        streamParms = Parms},
                    State) ->
    #'MegacoMessage_StreamDescriptor'{id    = tr_StreamID(Id, State),
                                      parms = tr_StreamParms(Parms, State)}.

tr_opt_LocalControlDescriptor(asn1_NOVALUE, State) ->
    #'MegacoMessage_OptLocalControlDescriptor'{label = false};
tr_opt_LocalControlDescriptor(Val, State) ->
    #'MegacoMessage_OptLocalControlDescriptor'{label = true,
                                               value = tr_LocalControlDescriptor(Val, State)}.

tr_LocalControlDescriptor(#'LocalControlDescriptor'{streamMode    = Mode,
                                                    reserveGroup  = Group,
                                                    reserveValue  = Value,
                                                    propertyParms = Props},
                          State) ->
    #'MegacoMessage_LocalControlDescriptor'{streamMode    = tr_opt_StreamMode(Mode, State),
                                            reserveGroup  = tr_opt_bool(Group, State),
                                            reserveValue  = tr_opt_bool(Value, State),
                                            propertyParms = [tr_PropertyParm(P, State) || P <- Props]}.

tr_opt_StreamMode(asn1_NOVALUE, State) ->
    #'MegacoMessage_OptStreamMode'{label = false};
tr_opt_StreamMode(Val, State) ->
    #'MegacoMessage_OptStreamMode'{label = true, value = tr_StreamMode(Val, State)}.

tr_StreamMode(Mode, State) ->
    case Mode of
        sendOnly -> 'StreamMode_sendOnly';
        recvOnly -> 'StreamMode_recvOnly';
        sendRecv -> 'StreamMode_sendRecv';
        inactive -> 'StreamMode_inactive';
        loopBack -> 'StreamMode_loopBack'
    end.

tr_Name(Name, State) ->
    Name.

tr_PkgdName(Name, State) ->
    Name.

tr_opt_LocalRemoteDescriptor(asn1_NOVALUE, State) ->
    #'MegacoMessage_OptLocalRemoteDescriptor'{label = false};
tr_opt_LocalRemoteDescriptor(Val, State) ->
    #'MegacoMessage_OptLocalRemoteDescriptor'{label = true,
                                              value = tr_LocalRemoteDescriptor(Val, State)}.
tr_LocalRemoteDescriptor(#'LocalRemoteDescriptor'{propGrps = Groups}, State) ->
    #'MegacoMessage_LocalRemoteDescriptor'{propGrps = [tr_PropertyGroup(G, State) || G <- Groups]}.

tr_PropertyGroup(Props, State) ->
    [tr_PropertyParm(P, State) || P <- Props].

tr_PropertyParm(#'PropertyParm'{name      = Name,
                                value     = Value,
                                extraInfo = Extra},
                State) ->
    #'MegacoMessage_PropertyParm'{name      = tr_PkgdName(Name, State),
                                  value     = tr_Value(Value, State),
                                  extraInfo = tr_opt_extraInfo(Extra, State)}.

tr_opt_extraInfo(asn1_NOVALUE, State) ->
    #'MegacoMessage_OptExtraInfoUnion'{label = false};
tr_opt_extraInfo({relation,Val}, State) ->
    #'MegacoMessage_OptExtraInfoUnion'{label = true,
                                       value = tr_extraInfo(Val, State)}.

tr_extraInfo({Tag, Val}, State) ->
    case Tag of
        relation ->
            #'MegacoMessage_ExtraInfoUnion'{label = 'ExtraInfoChoice_relation',
                                            value = tr_Relation(Val, State)};
        range ->
            #'MegacoMessage_ExtraInfoUnion'{label = 'ExtraInfoChoice_range',
                                            value = tr_bool(Val, State)};
        sublist ->
            #'MegacoMessage_ExtraInfoUnion'{label = 'ExtraInfoChoice_sublist',
                                            value = tr_bool(Val, State)}
    end.

tr_Relation(Val, State) ->
    case Val of
        greaterThan -> 'Relation_greaterThan';
        smallerThan -> 'Relation_smallerThan';
        unequalTo   -> 'Relation_unequalTo'
    end.

tr_opt_TerminationStateDescriptor(asn1_NOVALUE, State) ->
    #'MegacoMessage_OptTerminationStateDescriptor'{label = false};
tr_opt_TerminationStateDescriptor(Val, State) ->
    #'MegacoMessage_OptTerminationStateDescriptor'{label = true,
                                                   value = tr_TerminationStateDescriptor(Val, State)}.

tr_TerminationStateDescriptor(#'TerminationStateDescriptor'{propertyParms      = Props,
                                                            eventBufferControl = Control,
                                                            serviceState       = Service},
                              State) ->
    #'MegacoMessage_TerminationStateDescriptor'{propertyParms      = [tr_PropertyParm(P, State) || P <- Props],
                                                eventBufferControl = tr_opt_EventBufferControl(Control, State),
                                                serviceState       = tr_opt_ServiceState(Service, State)}.

tr_opt_EventBufferControl(asn1_NOVALUE, State) ->
    #'MegacoMessage_OptEventBufferControl'{label = false};
tr_opt_EventBufferControl(Val, State) ->
    #'MegacoMessage_OptEventBufferControl'{label = true,
                                           value = tr_EventBufferControl(Val, State)}.

tr_EventBufferControl(Control, State) ->
    case Control of
        off      -> 'EventBufferControl_off';
        lockStep -> 'EventBufferControl_lockStep'
    end.

tr_opt_ServiceState(asn1_NOVALUE, State) ->
    #'MegacoMessage_OptServiceState'{label = false};
tr_opt_ServiceState(Val, State) ->
    #'MegacoMessage_OptServiceState'{label = true,
                                     value = tr_ServiceState(Val, State)}.

tr_ServiceState(Service, State) ->
    case Service of
        test     -> 'ServiceState_test';
        outOfSvc -> 'ServiceState_outOfSvc';
        inSvc    -> 'ServiceState_inSvc'
    end.

tr_MuxDescriptor(#'MuxDescriptor'{muxType  = Type,
                                  termList = IdList},
                 State) ->
    #'MegacoMessage_MuxDescriptor'{type  = tr_MuxType(Type, State),
                                   termIdList = [tr_TerminationID(Id, State) || Id <- IdList]}.

tr_MuxType(Type, State) ->
    case Type of
        h221 -> 'MuxType_h221';
        h223 -> 'MuxType_h223';
        h226 -> 'MuxType_h226';
        v76  -> 'MuxType_v76'
    end.

tr_opt_StreamID(asn1_NOVALUE, State) ->
    #'MegacoMessage_OptStreamID'{label = false};
tr_opt_StreamID(Id, State) ->
    #'MegacoMessage_OptStreamID'{label = true,
                                 value = tr_StreamID(Id, State)}.

tr_StreamID(Id, State) ->
    Id.

tr_EventsDescriptor(#'EventsDescriptor'{requestID = Id,
                                        eventList = Events},
                    State) ->
    #'MegacoMessage_EventsDescriptor'{requestID = tr_opt_RequestID(Id, State),
                                      eventList = [tr_RequestedEvent(E, State) || E <- Events]}.

tr_RequestedEvent(#'RequestedEvent'{pkgdName    = Name,
                                    streamID    = Id,
                                    evParList   = Parms,
                                    eventAction = Actions},
                  State)  ->
    #'MegacoMessage_RequestedEvent'{name    = tr_PkgdName(Name, State),
                                    streamID    = tr_opt_StreamID(Id, State),
                                    eventAction = tr_opt_RequestedActions(Actions, State),
                                    evParList   = [tr_EventParameter(P, Name, State) || P <- Parms]}.

tr_opt_RequestedActions(asn1_NOVALUE, State) ->
    #'MegacoMessage_OptRequestedActions'{label = false};
tr_opt_RequestedActions(Val, State) ->
    #'MegacoMessage_OptRequestedActions'{label = true,
                                         value = tr_RequestedActions(Val, State)}.

tr_RequestedActions(#'RequestedActions'{keepActive        = Keep,
                                        eventDM           = DM,
                                        secondEvent       = Event,
                                        signalsDescriptor = SigDesc},
                    State) ->
    #'MegacoMessage_RequestedActions'{keepActive        = tr_opt_bool(Keep, State),
                                      eventDM           = tr_opt_EventDM(DM, State),
                                      secondEvent       = tr_opt_SecondEventsDescriptor(Event, State),
                                      signalsDescriptor = tr_opt_SignalsDescriptor(SigDesc, State)}.

tr_opt_EventDM(asn1_NOVALUE, State) ->
    #'MegacoMessage_OptEventDMUnion'{label = false};
tr_opt_EventDM(Val, State) ->
    #'MegacoMessage_OptEventDMUnion'{label = true,
                                     value = tr_EventDM(Val, State)}.

tr_EventDM({Tag, Val}, State) ->
    case Tag of
        digitMapName  ->
            #'MegacoMessage_EventDMUnion'{label = 'digitMapName',
                                          value = tr_DigitMapName(Val, State)};
        digitMapValue ->
            #'MegacoMessage_EventDMUnion'{label = 'digitMapValue',
                                          value = tr_DigitMapValue(Val, State)}
    end.

tr_opt_SecondEventsDescriptor(asn1_NOVALUE, State) ->
    #'MegacoMessage_OptSecondEventsDescriptor'{label = false};
tr_opt_SecondEventsDescriptor(Val, State) ->
    #'MegacoMessage_OptSecondEventsDescriptor'{label = true,
                                               value = tr_SecondEventsDescriptor(Val, State)}.

tr_SecondEventsDescriptor(#'SecondEventsDescriptor'{requestID = Id,
                                                    eventList = Events},
                          State) ->
    #'MegacoMessage_SecondEventsDescriptor'{id = tr_RequestID(Id, State),
                                            eventList = [tr_SecondRequestedEvent(E, State) || E <- Events]}.

tr_SecondRequestedEvent(#'SecondRequestedEvent'{pkgdName    = Name,
                                                streamID    = Id,
                                                evParList   = Parms,
                                                eventAction = Actions},
                        State) ->
    #'MegacoMessage_SecondRequestedEvent'{name        = tr_PkgdName(Name, State),
                                          streamID    = tr_opt_StreamID(Id, State),
                                          eventAction = tr_opt_SecondRequestedActions(Actions, State),
                                          evParList   = [tr_EventParameter(P, Name, State) || P <- Parms]}.


tr_opt_SecondRequestedActions(asn1_NOVALUE, State) ->