megaco_text_gen_prev3c.hrl

OTP是开放电信平台的简称

     [?LBRKT, ?RBRKT]
    ];
enc_AuditDescriptor(#'AuditDescriptor'{auditToken = [],
				       auditPropertyToken = asn1_NOVALUE}, 
		    _State) ->
%     d("enc_AuditDescriptor([]) -> entry"),
    [
     ?AuditToken,
     [?LBRKT, ?RBRKT]
    ];
enc_AuditDescriptor(#'AuditDescriptor'{auditToken = List,
				       auditPropertyToken = asn1_NOVALUE}, 
		    State) ->
    [
     ?AuditToken,
     [
      ?LBRKT_INDENT(State),
      enc_list([{List, fun enc_auditItem/2}], ?INC_INDENT(State)),
      ?RBRKT_INDENT(State)
     ]
    ];
%% - v2 -
enc_AuditDescriptor(#'AuditDescriptor'{auditToken = asn1_NOVALUE,
				       auditPropertyToken = Prop}, 
		    State) ->
    [
     ?AuditToken,
     [
      ?LBRKT_INDENT(State),
      enc_auditPropertyToken(Prop, ?INC_INDENT(State)),
      ?RBRKT_INDENT(State)
     ]
    ];
enc_AuditDescriptor(#'AuditDescriptor'{auditToken = List,
				       auditPropertyToken = Prop}, 
		    State) ->
    [
     ?AuditToken,
     [
      ?LBRKT_INDENT(State),
      enc_list([{List, fun enc_auditItem/2}], ?INC_INDENT(State)),
      ?COMMA_INDENT(State), 
      enc_auditPropertyToken(Prop, ?INC_INDENT(State)),  % v2
      ?RBRKT_INDENT(State)
     ]
    ].

enc_auditItem(signalsToken, _State) ->
    ?SignalsToken;
enc_auditItem(eventBufferToken, _State) -> 
    ?EventBufferToken;
enc_auditItem(eventsToken, _State) ->
    ?EventsToken;
enc_auditItem(Val, State) ->
    enc_auditReturnItem(Val, State).


enc_auditReturnItem(muxToken, _State) ->
    ?MuxToken;
enc_auditReturnItem(modemToken, _State) ->
    ?ModemToken;
enc_auditReturnItem(mediaToken, _State) ->
    ?MediaToken;
enc_auditReturnItem(digitMapToken, _State) ->
    ?DigitMapToken;
enc_auditReturnItem(statsToken, _State) ->
    ?StatsToken;
enc_auditReturnItem(observedEventsToken, _State) ->
    ?ObservedEventsToken;
enc_auditReturnItem(packagesToken, _State) ->
    ?PackagesToken.


%% - v2 begin -

enc_auditPropertyToken([], _State) ->
    [];
enc_auditPropertyToken([Param | Params], State) ->
    [enc_IndAudauditReturnParameter(Param, State),
     [[?COMMA_INDENT(State), 
       enc_IndAudauditReturnParameter(P, State)] || P <- Params]].


enc_IndAudauditReturnParameter({Tag, Val}, State) ->
    case Tag of
	indAudMediaDescriptor ->
	    enc_IndAudMediaDescriptor(Val, State);
	indAudEventsDescriptor ->
	    enc_IndAudEventsDescriptor(Val, State);
	indAudSignalsDescriptor ->
	    enc_IndAudSignalsDescriptor(Val, State);
	indAudDigitMapDescriptor ->
	    enc_IndAudDigitMapDescriptor(Val, State); 
	indAudEventBufferDescriptor ->
	    enc_IndAudEventBufferDescriptor(Val, State);
	indAudStatisticsDescriptor ->
	    enc_IndAudStatisticsDescriptor(Val, State);
	indAudPackagesDescriptor ->
	    enc_IndAudPackagesDescriptor(Val, State);
	_ ->
	    error({invalid_IndAudauditReturnParameter_tag, Tag})
    end.

enc_IndAudMediaDescriptor(
  #'IndAudMediaDescriptor'{termStateDescr = asn1_NOVALUE,
			   streams        = Streams}, State) ->
    [
     ?MediaToken,
     ?LBRKT_INDENT(State),
     enc_IndAudMediaDescriptor_streams(Streams, ?INC_INDENT(State)),
     ?RBRKT_INDENT(State)
    ];
enc_IndAudMediaDescriptor(
  #'IndAudMediaDescriptor'{termStateDescr = TSD,
			   streams        = asn1_NOVALUE}, State) ->
    [
     ?MediaToken,
     ?LBRKT_INDENT(State),
     enc_IndAudTerminationStateDescriptor(TSD, ?INC_INDENT(State)),
     ?RBRKT_INDENT(State)
    ];
enc_IndAudMediaDescriptor(
  #'IndAudMediaDescriptor'{termStateDescr = TSD,
			   streams        = Streams}, State) ->
    [
     ?MediaToken,
     ?LBRKT_INDENT(State),
     enc_IndAudTerminationStateDescriptor(TSD, ?INC_INDENT(State)),
     ?COMMA_INDENT(State), 
     enc_IndAudMediaDescriptor_streams(Streams, ?INC_INDENT(State)),
     ?RBRKT_INDENT(State)
    ].

enc_IndAudMediaDescriptor_streams({oneStream, Val}, State) ->
    enc_IndAudStreamParms(Val, State);
enc_IndAudMediaDescriptor_streams({multiStream, Val}, State) ->
    enc_IndAudMediaDescriptor_multiStream(Val, State);
enc_IndAudMediaDescriptor_streams({Tag, _Val}, _State) ->
    error({invalid_IndAudMediaDescriptor_streams_tag, Tag}).

enc_IndAudTerminationStateDescriptor(
  #'IndAudTerminationStateDescriptor'{propertyParms      = [],
				      eventBufferControl = asn1_NOVALUE,
				      serviceState       = 'NULL',
				      serviceStateSel    = asn1_NOVALUE}, 
  _State) ->
    [
     ?TerminationStateToken,
     ?LBRKT_INDENT(_State),
     ?ServiceStatesToken,
     ?RBRKT_INDENT(_State)
    ];
enc_IndAudTerminationStateDescriptor(
  #'IndAudTerminationStateDescriptor'{propertyParms      = [],
				      eventBufferControl = asn1_NOVALUE,
				      serviceState       = asn1_NOVALUE,
				      serviceStateSel    = SSS}, 
  State) when SSS =/= asn1_NOVALUE ->
    [
     ?TerminationStateToken,
     ?LBRKT_INDENT(State),
     enc_serviceState(SSS, State), 
     ?RBRKT_INDENT(State)
    ];
enc_IndAudTerminationStateDescriptor(
  #'IndAudTerminationStateDescriptor'{propertyParms      = [],
				      eventBufferControl = 'NULL',
				      serviceState       = asn1_NOVALUE,
				      serviceStateSel    = asn1_NOVALUE}, 
  _State) ->
    [
     ?TerminationStateToken,
     ?LBRKT_INDENT(_State),
     ?BufferToken,
     ?RBRKT_INDENT(_State)
    ];
enc_IndAudTerminationStateDescriptor(
  #'IndAudTerminationStateDescriptor'{propertyParms      = [Parms],
				      eventBufferControl = asn1_NOVALUE,
				      serviceState       = asn1_NOVALUE,
				      serviceStateSel    = asn1_NOVALUE}, 
  State) ->
    #'IndAudPropertyParm'{name = Name} = Parms,
    [
     ?TerminationStateToken,
     ?LBRKT_INDENT(State),
     enc_PkgdName(Name, State),
     ?RBRKT_INDENT(State)
    ].

enc_IndAudStreamParms(
  #'IndAudStreamParms'{localControlDescriptor = LCD,
		       localDescriptor        = LD, 
		       remoteDescriptor       = RD, 
		       statisticsDescriptor   = SD}, State) ->
    [
     enc_list([{[LCD], fun enc_IndAudLocalControlDescriptor/2},
	       {[LD],  fun enc_remoteDescriptor/2},
	       {[RD],  fun enc_localDescriptor/2},
	       {[SD],  fun enc_IndAudStatisticsDescriptor/2}], 
	      ?INC_INDENT(State))
    ].

enc_IndAudLocalControlDescriptor(
  #'IndAudLocalControlDescriptor'{streamMode    = SM,
				  reserveValue  = RV,
				  reserveGroup  = RG,
				  propertyParms = PP,
				  streamModeSel = asn1_NOVALUE}, State) ->
    [
     ?LocalControlToken,
     ?LBRKT_INDENT(State),
     enc_list([{[SM], fun('NULL', _) -> ?ModeToken end},
	       {[RV], fun('NULL', _) -> ?ReservedValueToken end},
	       {[RG], fun('NULL', _) -> ?ReservedGroupToken end},
	       {PP,   fun enc_IndAudPropertyParm/2}],
	      ?INC_INDENT(State)),
     ?RBRKT_INDENT(State)
    ];
enc_IndAudLocalControlDescriptor(
  #'IndAudLocalControlDescriptor'{streamMode    = asn1_NOVALUE,
				  reserveValue  = RV,
				  reserveGroup  = RG,
				  propertyParms = PP,
				  streamModeSel = SMS}, State) ->
    [
     ?LocalControlToken,
     ?LBRKT_INDENT(State),
     enc_list([{[RV],  fun('NULL', _) -> ?ReservedValueToken end},
	       {[RG],  fun('NULL', _) -> ?ReservedGroupToken end},
	       { PP,   fun enc_IndAudPropertyParm/2},
	       {[SMS], fun enc_StreamMode/2}], 
	      ?INC_INDENT(State)),
     ?RBRKT_INDENT(State)
    ].

enc_IndAudPropertyParm(#'IndAudPropertyParm'{name = Name, propertyParms = PP}, 
		       State) ->
    [
     enc_list([{[Name], fun enc_PkgdName/2},
	       {[PP],   fun enc_PropertyParm/2}], State)
    ].

enc_IndAudMediaDescriptor_multiStream(Val, State) when is_list(Val) ->
    [
     enc_list([{Val, fun enc_IndAudStreamDescriptor/2}], State)
    ];
enc_IndAudMediaDescriptor_multiStream(Val, _State) ->
    error({invalid_IndAudMediaDescriptor_multiStream, Val}).

enc_IndAudStreamDescriptor(#'IndAudStreamDescriptor'{streamID    = SID,
						     streamParms = Parms}, 
			   State) ->
    [
     ?StreamToken,
     ?EQUAL,
     enc_StreamID(SID, State),
     ?LBRKT_INDENT(State),
     enc_IndAudStreamParms(Parms, ?INC_INDENT(State)),
     ?RBRKT_INDENT(State)
    ].
    
enc_IndAudEventBufferDescriptor(
  #'IndAudEventBufferDescriptor'{eventName = EvName,
				 streamID  = ID}, State) ->
    [
     ?EventBufferToken,
     ?LBRKT_INDENT(State),
     enc_PkgdName(EvName, State),
     enc_IndAudEventBufferDescriptor_eventSpec(ID, ?INC_INDENT(State)),
     ?RBRKT_INDENT(State)
    ].

enc_IndAudEventBufferDescriptor_eventSpec(asn1_NOVALUE, _State) ->
    [
    ];
enc_IndAudEventBufferDescriptor_eventSpec({eventParameterName, ParamName}, 
					  State) ->
    [
     ?LBRKT_INDENT(State),
     enc_Name(ParamName, State),
     ?RBRKT_INDENT(State)
    ];
enc_IndAudEventBufferDescriptor_eventSpec({eventStream, ID}, State) ->
    [
     ?LBRKT_INDENT(State),
     enc_eventStream(ID, ?INC_INDENT(State)),
     ?RBRKT_INDENT(State)
    ];
enc_IndAudEventBufferDescriptor_eventSpec(ID, State) ->
    [
     ?LBRKT_INDENT(State),
     enc_eventStream(ID, ?INC_INDENT(State)),
     ?RBRKT_INDENT(State)
    ].

enc_IndAudEventsDescriptor(
  #'IndAudEventsDescriptor'{requestID = asn1_NOVALUE,
			    pkgdName  = Name,
			    streamID  = asn1_NOVALUE}, State) ->
    [
     ?EventsToken,
     ?LBRKT_INDENT(State),
     enc_PkgdName(Name, State), 
     ?RBRKT_INDENT(State)
    ];
enc_IndAudEventsDescriptor(
  #'IndAudEventsDescriptor'{requestID = RID,
			    pkgdName  = Name,
			    streamID  = asn1_NOVALUE}, State) ->
    [
     ?EventsToken,
     ?EQUAL,
     enc_RequestID(RID, State),
     ?LBRKT_INDENT(State),
     enc_PkgdName(Name, State), 
     ?RBRKT_INDENT(State)
    ].


enc_IndAudSignalsDescriptor(asn1_NOVALUE, _State) ->
    [
     ?SignalsToken,
     ?LBRKT_INDENT(_State),
     ?RBRKT_INDENT(_State)
    ];
enc_IndAudSignalsDescriptor(Val, State) ->
    [
     ?SignalsToken,
     ?LBRKT_INDENT(State),
     enc_IndAudSignalsDescriptor_value(Val, ?INC_INDENT(State)),
     ?RBRKT_INDENT(State)
    ].

enc_IndAudSignalsDescriptor_value({signal, Val}, State) ->
    enc_IndAudSignal(Val, State);
enc_IndAudSignalsDescriptor_value({seqSigList, Val}, State) ->
    enc_IndAudSeqSigList(Val, State).
    
enc_IndAudSignal(#'IndAudSignal'{signalName      = SignalName,
				 streamID        = asn1_NOVALUE,
				 signalRequestID = asn1_NOVALUE}, State) ->
    [
     enc_SignalName(SignalName, State)
    ];
enc_IndAudSignal(#'IndAudSignal'{signalName      = SignalName,
				 streamID        = SID,
				 signalRequestID = SRID}, State) ->
    [
     enc_SignalName(SignalName, State),
     ?LBRKT_INDENT(State),
     enc_list([{[SID],  fun enc_StreamID/2},
	       {[SRID], fun enc_sigRequestID/2}],
	      State),
     ?RBRKT_INDENT(State)     
    ].

enc_IndAudSeqSigList(#'IndAudSeqSigList'{id         = ID,
					 signalList = asn1_NOVALUE}, 
		     State) ->
    [
     ?SignalListToken,
     ?EQUAL,
     enc_UINT16(ID, State)
    ];
enc_IndAudSeqSigList(#'IndAudSeqSigList'{id         = ID,
					 signalList = SL}, 
		     State) ->
    [
     ?SignalListToken,
     ?EQUAL,
     enc_UINT16(ID, State),
     ?LBRKT_INDENT(State),
     enc_IndAudSignal(SL, ?INC_INDENT(State)),
     ?RBRKT_INDENT(State)
    ].

enc_IndAudDigitMapDescriptor(#'IndAudDigitMapDescriptor'{digitMapName = Name}, 
			     State) ->
    [
     ?DigitMapToken,
     ?EQUAL,
     enc_DigitMapName(Name, State)
    ].

enc_IndAudStatisticsDescriptor(#'IndAudStatisticsDescriptor'{statName = Name}, 
			       State) ->
    [
     ?StatsToken,
     ?LBRKT_INDENT(State),
     enc_PkgdName(Name, State),     
     ?RBRKT_INDENT(State)    
    ].


enc_IndAudPackagesDescriptor(#'IndAudPackagesDescriptor'{packageName    = N,
							 packageVersion = V}, 
			     State) ->
    [
     ?PackagesToken,
     ?LBRKT_INDENT(State),
     enc_Name(N, State),
     "-",
     enc_UINT16(V, State),
     ?RBRKT_INDENT(State) 
    ].


%% - v2 end -

    
enc_TerminationAudit({'TerminationAudit', Val}, State) ->
    enc_TerminationAudit(Val, State);
enc_TerminationAudit([Mand | Opt], State) ->
    [enc_AuditReturnParameter(Mand, State),
     [[?COMMA_INDENT(State), enc_AuditReturnParameter(Val, State)] || Val <- Opt]].

enc_AuditReturnParameter({'AuditReturnParameter',Val}, State) ->
    enc_AuditReturnParameter(Val, State);
enc_AuditReturnParameter({Tag, Val}, State) ->
%%     d("enc_AuditReturnParameter -> entry with"
%%       "~n   Tag: ~p"
%%       "~n   Val: ~p", [Tag, Val]),
    case Tag of
	mediaDescriptor ->
	    enc_MediaDescriptor(Val, State);
	modemDescriptor ->
	    enc_ModemDescriptor(Val, State);
	muxDescriptor ->
	    enc_MuxDescriptor(Val, State);