megaco_text_gen_prev3c.hrl

OTP是开放电信平台的简称

	eventsDescriptor ->
	    enc_EventsDescriptor(Val, State);
	signalsDescriptor ->
	    enc_SignalsDescriptor(Val, State);
	digitMapDescriptor ->
	    enc_DigitMapDescriptor(Val, State);
	observedEventsDescriptor ->
	    enc_ObservedEventsDescriptor(Val, State);
	eventBufferDescriptor ->
	    enc_EventBufferDescriptor(Val, State);
	statisticsDescriptor ->
	    enc_StatisticsDescriptor(Val, State);
	packagesDescriptor ->
	    enc_PackagesDescriptor(Val, State);
	errorDescriptor ->
	    enc_ErrorDescriptor(Val, State);
        emptyDescriptors ->
            enc_EmptyDescriptors(Val, State);
	_ ->
	    error({invalid_AuditReturnParameter_tag, Tag})
    end.

enc_EmptyDescriptors(#'AuditDescriptor'{auditToken = asn1_NOVALUE}, _State) ->
    [];
enc_EmptyDescriptors(#'AuditDescriptor'{auditToken = []}, _State) ->
    [];
enc_EmptyDescriptors(#'AuditDescriptor'{auditToken = List}, State) ->
%%     d("enc_AuditReturnParameter -> entry with"
%%       "~n   List: ~p", [List]),
    enc_list([{List, fun enc_auditReturnItem/2}], State).


enc_NotifyRequest(#'NotifyRequest'{terminationID            = TIDs,
				   observedEventsDescriptor = OED,
				   errorDescriptor          = asn1_NOVALUE}, 
		  State) ->
    [
     %% Assume that Token is added elsewhere
     ?EQUAL,
     enc_termIDList(TIDs, State),
     ?LBRKT_INDENT(State),
     enc_ObservedEventsDescriptor(OED, ?INC_INDENT(State)),
     ?RBRKT_INDENT(State)
    ];
enc_NotifyRequest(#'NotifyRequest'{terminationID            = TIDs,
				   observedEventsDescriptor = OED,
				   errorDescriptor          = ED}, State) ->
    [
     %% Assume that Token is added elsewhere
     ?EQUAL,
     enc_termIDList(TIDs, State),
     ?LBRKT_INDENT(State),
     enc_ObservedEventsDescriptor(OED, ?INC_INDENT(State)),
     ?COMMA,
     enc_ErrorDescriptor(ED, ?INC_INDENT(State)),
     ?RBRKT_INDENT(State)
    ].

enc_NotifyReply(#'NotifyReply'{terminationID   = TIDs,
			       errorDescriptor = asn1_NOVALUE}, State) ->
    [
     %% Assume that Token is added elsewhere
     ?EQUAL,
     enc_termIDList(TIDs, State)
    ];
enc_NotifyReply(#'NotifyReply'{terminationID   = TIDs,
			       errorDescriptor = ED}, State) ->
    [
     %% Assume that Token is added elsewhere
     ?EQUAL,
     enc_termIDList(TIDs, State),
     ?LBRKT_INDENT(State),
     enc_ErrorDescriptor(ED, ?INC_INDENT(State)),
     ?RBRKT_INDENT(State)
    ].

enc_ObservedEventsDescriptor(
  #'ObservedEventsDescriptor'{requestId        = RID,
			      observedEventLst = OEL}, State) ->
    [
     ?ObservedEventsToken,
     ?EQUAL,
     enc_RequestID(RID, State),
     ?LBRKT_INDENT(State),
     enc_observedEvents(OEL, ?INC_INDENT(State)),
     ?RBRKT_INDENT(State)
    ].

enc_observedEvents([Mand | Opt], State) ->
    [enc_ObservedEvent(Mand, State),
     [[?COMMA_INDENT(State), enc_ObservedEvent(Val, State)] || Val <- Opt]].

%% ;time per event, because it might be buffered
%% observedEvent        = [ TimeStamp LWSP COLON] LWSP 
%% 			  pkgdName [ LBRKT observedEventParameter
%% 			  *(COMMA observedEventParameter) RBRKT ]
%% 
%% ;at-most-once eventStream, every eventParameterName at most once
%% observedEventParameter = eventStream / eventOther
enc_ObservedEvent(#'ObservedEvent'{eventName    = EN,
				   streamID     = SID,
				   eventParList = EPL,
				   timeNotation = asn1_NOVALUE}, State) ->
    [
     ?LWSP,
     enc_EventName(EN, State),
     enc_opt_brackets(
       enc_list([{[SID], fun enc_eventStream/2},
		 { EPL,  fun enc_eventOther/2}],
		?INC_INDENT(State)),
       State)
    ];
enc_ObservedEvent(#'ObservedEvent'{eventName    = EN,
				   streamID     = SID,
				   eventParList = EPL,
				   timeNotation = TN}, State) ->
    [
     enc_TimeNotation(TN, State),
     ?LWSP,
     ?COLON,
     ?LWSP,
     enc_EventName(EN, State),
     enc_opt_brackets(
       enc_list([{[SID], fun enc_eventStream/2},
		 {EPL,   fun enc_eventOther/2}],
		?INC_INDENT(State)),
       State)
    ].

enc_EventName({'EventName', Val}, State) ->
    enc_EventName(Val, State);
enc_EventName(Val, State) ->
    PkgdName = ?META_ENC(event, Val),
    enc_PkgdName(PkgdName, State).

enc_eventStream(Val, State) ->
    [
     ?StreamToken,
     ?EQUAL,
     enc_StreamID(Val, State)
    ].

enc_eventOther(#'EventParameter'{eventParameterName = Name,
				 value              = Value,
				 extraInfo          = Extra}, State) ->
    [
     enc_Name(Name, State),
     enc_propertyParmValues(Value, Extra, State)
    ].

enc_ServiceChangeRequest(
  #'ServiceChangeRequest'{terminationID      = TIDs,
			  serviceChangeParms = Parms}, State) ->
    [
     %% Assume that Token is added elsewhere
     ?EQUAL,
     enc_termIDList(TIDs, State),
     ?LBRKT_INDENT(State),
     enc_ServiceChangeParm(Parms, ?INC_INDENT(State)),
     ?RBRKT_INDENT(State)
    ].

%% serviceChangeReply   = ServiceChangeToken EQUAL TerminationID
%% 			  [LBRKT (errorDescriptor / 
%% 			  serviceChangeReplyDescriptor) RBRKT]
%% serviceChangeReplyDescriptor = ServicesToken LBRKT
%% 			  servChgReplyParm *(COMMA servChgReplyParm) RBRKT
%% 
%% ;at-most-once. Version is REQUIRED on first ServiceChange response
%% servChgReplyParm     = (serviceChangeAddress / serviceChangeMgcId /
%% 			  serviceChangeProfile / serviceChangeVersion )
enc_ServiceChangeReply(
  #'ServiceChangeReply'{terminationID       = TIDs,
			serviceChangeResult = Res}, State) ->
    [
     %% Assume that Token is added elsewhere
     ?EQUAL,
     enc_termIDList(TIDs, State),
     enc_ServiceChangeResult(Res, State)
     ].

enc_ServiceChangeResult({'ServiceChangeResult', Val}, State) ->
    enc_ServiceChangeResult(Val, State);
enc_ServiceChangeResult({errorDescriptor, Val}, State) ->
    [
     ?LBRKT_INDENT(State),
     enc_ErrorDescriptor(Val, ?INC_INDENT(State)),
     ?RBRKT_INDENT(State)
    ];
enc_ServiceChangeResult({serviceChangeResParms, Val}, State) ->
    case enc_ServiceChangeResParm(Val, ?INC_INDENT(?INC_INDENT(State))) of
	[] ->
	    [];
	ResParms ->
	    [
	     ?LBRKT_INDENT(State),
	     ?ServicesToken,
	     fun(_S) ->
		     [
		      ?LBRKT_INDENT(_S),
		      ResParms,
		      ?RBRKT_INDENT(_S)
		     ]
	     end(?INC_INDENT(State)),
	     ?RBRKT_INDENT(State)
	    ]
    end;
enc_ServiceChangeResult({Tag, _}, _State) ->
    error({invalid_ServiceChangeResult_tag, Tag}).

%% %% Required length of termination ID list is 1
%% enc_TerminationIDList1({'TerminationIDList',Val}, State) ->
%%     enc_TerminationIDList1(Val, State);
%% enc_TerminationIDList1([Singleton], State) ->
%%     enc_TerminationID(Singleton, State).

%% No required length of termination ID list
enc_TerminationIDList({'TerminationIDList',Val}, State) ->
    enc_TerminationIDList(Val, State);
enc_TerminationIDList([TID], State) ->
    [
     ?LBRKT_INDENT(State),
     enc_TerminationID(TID, State), 
     ?RBRKT_INDENT(State)
    ];
enc_TerminationIDList(TIDs, State) ->
    [
     ?LBRKT_INDENT(State),
     enc_list([{TIDs, fun enc_TerminationID/2}], State),
     ?RBRKT_INDENT(State)
    ].

enc_termIDList({'TerminationIDList',Val}, State) ->
    enc_termIDList(Val, State);
enc_termIDList([Singleton], State) ->
    enc_TerminationID(Singleton, State);
enc_termIDList(TidList, State) 
  when is_list(TidList) and (length(TidList) > 1) ->
%%     d("enc_termIDList -> entry with"
%%       "~n   TidList: ~p", [TidList]),
    State2 = ?INC_INDENT(State),
    [
     ?LSBRKT_INDENT(State),
     enc_list([{TidList, fun enc_TerminationID/2}], State2),
     ?RSBRKT_INDENT(State)
    ].

%% TerminationID        = "ROOT" / pathNAME / "$" / "*"
%% ; Total length of pathNAME must not exceed 64 chars.
%% pathNAME             = ["*"] NAME *("/" / "*"/ ALPHA / DIGIT /"_" / "$" ) 
%% 			  ["@" pathDomainName ]
enc_TerminationID(Tid, State)
  when record(Tid, megaco_term_id) ->
    List = [{Tid#megaco_term_id.id, fun enc_tid_component/2 }],
    enc_list(List, State, fun(_S) -> ?SLASH end, false).    

enc_tid_component(Component, State) when list(Component) ->
    [enc_tid_sub_component(Sub, State) || Sub <- Component];
enc_tid_component(Invalid, _State) ->
    error({invalid_id_list_component, Invalid}).

enc_tid_sub_component(Sub, _State) ->
    case Sub of
	all    -> ?megaco_all;
	choose -> ?megaco_choose;
	Char when integer(Char) -> Char
    end.

%% mediaDescriptor      = MediaToken LBRKT mediaParm *(COMMA mediaParm) RBRKT
%% ; at-most-once per item
%% ; and either streamParm or streamDescriptor but not both
%% mediaParm            = (streamParm / streamDescriptor / 
%% 			   terminationStateDescriptor)
%% ; at-most-once
%% streamParm           = ( localDescriptor / remoteDescriptor / 
%% 			   localControlDescriptor )
%% streamDescriptor     = StreamToken EQUAL StreamID LBRKT streamParm 
%% 			  *(COMMA streamParm) RBRKT
enc_MediaDescriptor(#'MediaDescriptor'{termStateDescr = TSD,
				       streams        = Streams}, State) ->
    [
     ?MediaToken,
     ?LBRKT_INDENT(State),
     enc_list([{[TSD], fun enc_TerminationStateDescriptor/2} |
	       decompose_streams(Streams)],
	      ?INC_INDENT(State)),
     ?RBRKT_INDENT(State)
    ].

decompose_streams(asn1_NOVALUE) ->
    [];
decompose_streams({'MediaDescriptor_streams',Val}) ->
    decompose_streams(Val);
decompose_streams({Tag, Val}) ->
    case Tag of
	oneStream ->
	    decompose_StreamParms(Val);
	multiStream ->
	    [{Val, fun enc_StreamDescriptor/2}];
	_ ->
	    error({invalid_streams_tag, Tag})
    end.

decompose_StreamParms(Val)
  when record(Val, 'StreamParms') ->
    [
     {[Val#'StreamParms'.localControlDescriptor],
      fun enc_LocalControlDescriptor/2},
     {[Val#'StreamParms'.localDescriptor],
      fun enc_localDescriptor/2},
     {[Val#'StreamParms'.remoteDescriptor],
      fun enc_remoteDescriptor/2},
     {[Val#'StreamParms'.statisticsDescriptor],
      fun enc_StatisticsDescriptor/2}
    ].

enc_StreamDescriptor(Val, State) 
    when record(Val, 'StreamDescriptor') ->
    [
     ?StreamToken,
     ?EQUAL,
     enc_StreamID(Val#'StreamDescriptor'.streamID, State),
     ?LBRKT_INDENT(State),
     enc_list(decompose_StreamParms(Val#'StreamDescriptor'.streamParms),
	      ?INC_INDENT(State)),
     ?RBRKT_INDENT(State)
    ].

%% localControlDescriptor = LocalControlToken LBRKT localParm 
%% 			    *(COMMA localParm) RBRKT
%% 
%% ; at-most-once per item
%% localParm            = ( streamMode / propertyParm /
%%                          reservedValueMode  / reservedGroupMode ) 
%% reservedValueMode       = ReservedValueToken EQUAL ( "ON" / "OFF" ) 
%% reservedGroupMode       = ReservedGroupToken EQUAL ( "ON" / "OFF" ) 
%% 
%% reservedMode	     = ReservedToken EQUAL ( "ON" / "OFF" )
%% 
%% streamMode           = ModeToken EQUAL streamModes
enc_LocalControlDescriptor(
  #'LocalControlDescriptor'{streamMode    = asn1_NOVALUE, 
			    reserveValue  = asn1_NOVALUE, 
			    reserveGroup  = asn1_NOVALUE, 
			    propertyParms = []}, _State) ->
    error({invalid_LocalControlDescriptor, empty});
enc_LocalControlDescriptor(
  #'LocalControlDescriptor'{streamMode    = SM, 
			    reserveValue  = RV, 
			    reserveGroup  = RG, 
			    propertyParms = PPs}, State) ->
    [
     ?LocalControlToken,
     ?LBRKT_INDENT(State),
     enc_list([{[SM], fun enc_StreamMode/2},
	       {[RG], fun enc_reservedGroupMode/2},
	       {[RV], fun enc_reservedValueMode/2},
	       {PPs,  fun enc_PropertyParm/2}], ?INC_INDENT(State)),
     ?RBRKT_INDENT(State)
    ].

enc_reservedGroupMode(Val, _State) ->
    [
     ?ReservedGroupToken,
     ?EQUAL,
     case Val of
	 false -> ?OffToken;
	 true  -> ?OnToken
     end
    ].

enc_reservedValueMode(Val, _State) ->
    [
     ?ReservedValueToken,
     ?EQUAL,
     case Val of
	 false -> ?OffToken;
	 true  -> ?OnToken
     end
    ].

enc_StreamMode({'StreamMode',Val}, State) ->
    enc_StreamMode(Val, State);
enc_StreamMode(Val, _State) ->
    [
     ?ModeToken,
     ?EQUAL,
     case Val of
	 sendOnly -> ?SendonlyToken;
	 recvOnly -> ?RecvonlyToken;
	 sendRecv -> ?SendrecvToken;
	 inactive -> ?InactiveToken;
	 loopBack -> ?LoopbackToken
     end
    ].

enc_Name({'Name',Val}, State) ->
    enc_Name(Val, State);
enc_Name(Val, State) ->
    %% BUGBUG: NAME = ALPHA *63(ALPHA / DIGIT / "_" )
    enc_STRING(Val, State, 1, 64).

enc_PkgdName({'PkgdName', Val}, State) ->
    enc_PkgdName(Val, State);
enc_PkgdName(Val, State) ->
    %% BUGBUG:  pkgdName =  (NAME / "*")  SLASH  (ItemID / "*" )
    enc_OCTET_STRING(Val, State, 1, 64).

enc_localDescriptor(Val, State) 
  when record(Val, 'LocalRemoteDescriptor') ->
    [
     ?LocalToken,
     ?LBRKT,
     enc_LocalRemoteDescriptor(Val, State),
     ?RBRKT_INDENT(State)
    ].

enc_remoteDescriptor(Val, State) 
  when record(Val, 'LocalRemoteDescriptor') ->
    [
     ?RemoteToken,
     ?LBRKT,
     enc_LocalRemoteDescriptor(Val, State),
     ?RBRKT_INDENT(State)
    ].

%% When text encoding the protocol, the descriptors consist of session
%% descriptions as defined i