megaco_text_gen_prev3a.hrl

OTP是开放电信平台的简称

     enc_TerminationIDList1(Val#'AmmRequest'.terminationID, State),
     enc_opt_brackets(
       enc_list([{Val#'AmmRequest'.descriptors, fun enc_ammDescriptor/2}],
		?INC_INDENT(State)),
       State)
    ].

enc_ammDescriptor({Tag, Desc}, State) ->
%     d("enc_ammDescriptor -> entry with"
%       "~n   Tag:  ~p"
%       "~n   Desc: ~p", [Tag, Desc]),
    case Tag of
	mediaDescriptor       -> enc_MediaDescriptor(Desc, State);
        modemDescriptor       -> enc_ModemDescriptor(Desc, State);      
        muxDescriptor         -> enc_MuxDescriptor(Desc, State);   
        eventsDescriptor      -> enc_EventsDescriptor(Desc, State);      
        eventBufferDescriptor -> enc_EventBufferDescriptor(Desc, State); 
        signalsDescriptor     -> enc_SignalsDescriptor(Desc, State);    
        digitMapDescriptor    -> enc_DigitMapDescriptor(Desc, State);    
        auditDescriptor       -> enc_AuditDescriptor(Desc, State);
        statisticsDescriptor  -> enc_StatisticsDescriptor(Desc, State);
	_ ->
	    error({invalid_ammDescriptor_tag, Tag})
    end.

enc_AmmsReply(#'AmmsReply'{terminationID = ID, 
			   terminationAudit = asn1_NOVALUE}, State) ->
%     d("enc_AmmsReply(asn1_NOVALUE) -> entry with"
%       "~n   ID: ~p", [ID]),
    [
     ?EQUAL,
     enc_TerminationIDList1(ID, State)
    ];
enc_AmmsReply(#'AmmsReply'{terminationID = ID, 
			   terminationAudit = []}, State) ->
%     d("enc_AmmsReply([]) -> entry with"
%       "~n   ID:  ~p", [ID]),
    [
     ?EQUAL,
     enc_TerminationIDList1(ID, State)
    ];
enc_AmmsReply(#'AmmsReply'{terminationID = ID, 
			   terminationAudit = Res}, State) ->
%     d("enc_AmmsReply -> entry with"
%       "~n   ID:  ~p"
%       "~n   Res: ~p", [ID, Res]),
    [
     ?EQUAL,
     enc_TerminationIDList1(ID, State),
     case lists:flatten(enc_TerminationAudit(Res, ?INC_INDENT(State))) of
	 [] ->
	     [];
	 L ->
	     [
	      ?LBRKT_INDENT(State), 
	      L,
	      ?RBRKT_INDENT(State)
	     ]
     end
    ].

enc_SubtractRequest(Val, State)
  when record(Val, 'SubtractRequest') ->
    [
     %% Assume that Token is added elsewhere
     ?EQUAL,
     enc_TerminationIDList1(Val#'SubtractRequest'.terminationID, State),
     case Val#'SubtractRequest'.auditDescriptor of
	 asn1_NOVALUE ->
	     [];
	 AuditDescr ->
	     [
	      ?LBRKT_INDENT(State) ,
	      enc_AuditDescriptor(AuditDescr, ?INC_INDENT(State)),
	      ?RBRKT_INDENT(State)
	     ]
     end
    ].    

enc_AuditRequest(Val, State)
  when record(Val, 'AuditRequest') ->
%     d("enc_AuditRequest -> entry with"
%       "~n   Val: ~p", [Val]),
    [
     %% Assume that Token is added elsewhere
     ?EQUAL,
     enc_TerminationIDList1([Val#'AuditRequest'.terminationID], State),
     case Val#'AuditRequest'.auditDescriptor of
	 asn1_NOVALUE ->
	     [];
	 AuditDescr ->
	     [
	      ?LBRKT_INDENT(State) ,
	      enc_AuditDescriptor(AuditDescr, ?INC_INDENT(State)),
	      ?RBRKT_INDENT(State)
	     ]
     end
    ].    

%% auditReply           = (AuditValueToken / AuditCapToken ) 
%% 			  ( contextTerminationAudit  / auditOther)
%% auditOther           = EQUAL TerminationID LBRKT 
%% 			  terminationAudit RBRKT
%% terminationAudit     = auditReturnParameter *(COMMA auditReturnParameter) 
%% 
%% contextTerminationAudit = EQUAL CtxToken ( terminationIDList / 
%% 			  LBRKT errorDescriptor RBRKT )
enc_AuditReply({Tag, Val}, State) ->
    case Tag of
	contextAuditResult ->
	    [
	     ?EQUAL,
	     ?CtxToken,
	     enc_TerminationIDListN(Val, State)
	    ];
	error ->
	    [
	     ?EQUAL,
	     ?CtxToken,
	     ?LBRKT_INDENT(State),
	     enc_ErrorDescriptor(Val, ?INC_INDENT(State)),
	     ?RBRKT_INDENT(State)
	    ]; 
	auditResult when record(Val, 'AuditResult') ->
	    enc_auditOther(Val, State);
	auditResult ->
	    error({invalid_auditResult, Val});
	_ ->
	    error({invalid_AuditReply_tag, Tag})
    end.

enc_auditOther(#'AuditResult'{terminationID = ID,
			      terminationAuditResult = asn1_NOVALUE}, State) ->
    [
     ?EQUAL,
     enc_TerminationID(ID, State)
    ];
enc_auditOther(#'AuditResult'{terminationID = ID,
			      terminationAuditResult = []}, State) ->
    [
     ?EQUAL,
     enc_TerminationID(ID, State)
    ];
enc_auditOther(#'AuditResult'{terminationID = ID,
			      terminationAuditResult = Res}, State) ->
    [
     ?EQUAL,
     enc_TerminationID(ID, State),
     case lists:flatten(enc_TerminationAudit(Res, ?INC_INDENT(State))) of
	 [] ->
	     [];
	 L ->
	     [
	      ?LBRKT_INDENT(State), 
	      L,
	      ?RBRKT_INDENT(State)
	     ]
     end
    ].

    
enc_AuditDescriptor(#'AuditDescriptor'{auditToken = asn1_NOVALUE,
				       auditPropertyToken = asn1_NOVALUE}, 
		    _State) ->
%     d("enc_AuditDescriptor(asn1_NOVALUE) -> entry"),
    [
     ?AuditToken,
     [?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) ->
%     d("enc_AuditDescriptor -> entry with",
%       "~n   List: ~p", [List]),
    [
     ?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) ->
%     d("enc_AuditDescriptor -> entry with",
%       "~n   Prop: ~p", [Prop]),
    [
     ?AuditToken,
     [
      ?LBRKT_INDENT(State),
      enc_auditPropertyToken(Prop, ?INC_INDENT(State)),
      ?RBRKT_INDENT(State)
     ]
    ];
enc_AuditDescriptor(#'AuditDescriptor'{auditToken = List,
				       auditPropertyToken = Prop}, 
		    State) ->
%     d("enc_AuditDescriptor -> entry with",
%       "~n   List: ~p"
%       "~n   Prop: ~p", [List, Prop]),
    [
     ?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) ->
%     d("enc_auditPropertyToken -> entry with",
%       "~n   Param: ~p", [Param]),    
    [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.

%% The ASN.1 does not limit to just one of termStateDescr or streams,
%% but the ABNF seams to do that...
enc_IndAudMediaDescriptor(
  #'IndAudMediaDescriptor'{termStateDescr = asn1_NOVALUE,
			   streams = Streams}, State) ->
%     d("enc_IndAudMediaDescriptor -> entry with",
%       "~n   Streams: ~p", [Streams]),    
    [
     ?MediaToken,
     ?LBRKT_INDENT(State),
     enc_IndAudMediaDescriptor_streams(Streams, ?INC_INDENT(State)),
     ?RBRKT_INDENT(State)
    ];
enc_IndAudMediaDescriptor(#'IndAudMediaDescriptor'{termStateDescr = TSD,
						   streams = asn1_NOVALUE}, 
			  State) ->
%     d("enc_IndAudMediaDescriptor -> entry with",
%       "~n   TSD: ~p", [TSD]),    
    [
     ?MediaToken,
     ?LBRKT_INDENT(State),
     enc_IndAudTerminationStateDescriptor(TSD, ?INC_INDENT(State)),
     ?RBRKT_INDENT(State)
    ].

enc_IndAudMediaDescriptor_streams({Tag, Val}, State) ->
%     d("enc_IndAudMediaDescriptor_streams -> entry with",
%       "~n   Tag: ~p"
%       "~n   Val: ~p", [Tag, Val]),    
    case Tag of
	oneStream ->
	    enc_IndAudStreamParms(Val, State);
	multiStream ->
	    enc_IndAudMediaDescriptor_multiStream(Val, State);
	_ ->
	    error({invalid_IndAudMediaDescriptor_streams_tag, Tag})
    end.

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

%% In text, localDescriptor and remoteDescriptor are not allowed!!
enc_IndAudStreamParms(
  #'IndAudStreamParms'{localControlDescriptor = LCD,
		       localDescriptor        = asn1_NOVALUE, 
		       remoteDescriptor       = asn1_NOVALUE, 
		       statisticsDescriptor   = SD}, State) ->
%   d("enc_IndAudStreamParms -> entry with"
%     "~n   LCD: ~p"
%     "~n   SD:  ~p", [LCD, SD]),
    [
     enc_list([{[LCD], fun enc_IndAudLocalControlDescriptor/2},
	       {[SD],  fun enc_IndAudStatisticsDescriptor/2}], 
	      ?INC_INDENT(State))
    ].

enc_IndAudLocalControlDescriptor(Val, State)
  when record(Val, 'IndAudLocalControlDescriptor') ->
    [
     ?LocalControlToken,
     ?LBRKT_INDENT(State),
     enc_list([{[Val#'IndAudLocalControlDescriptor'.streamMode],
		fun('NULL', _) -> ?ModeToken end},
	       {[Val#'IndAudLocalControlDescriptor'.reserveValue],
		fun('NULL', _) -> ?ReservedValueToken end},
	       {[Val#'IndAudLocalControlDescriptor'.reserveGroup],
		fun('NULL', _) -> ?ReservedGroupToken end},
	       {Val#'IndAudLocalControlDescriptor'.propertyParms,
		fun enc_IndAudPropertyParm/2}],
	      ?INC_INDENT(State)),
     ?RBRKT_INDENT(State)
    ].

enc_IndAudPropertyParm(#'IndAudPropertyParm'{name = PkgdName}, State) ->
    enc_PkgdName(PkgdName, State).

enc_IndAudMediaDescriptor_multiStream([Val], State) ->
%   d("enc_IndAudMediaDescriptor_multiStream -> entry with"
%     "~n   Val: ~p", [Val]),
    [
     enc_IndAudStreamDescriptor(Val, ?INC_INDENT(State))
    ];
enc_IndAudMediaDescriptor_multiStream(Vals, _State) when list(Vals) ->
    error({invalid_IndAudMediaDescriptor_multiStream_length, Vals});
enc_IndAudMediaDescriptor_multiStream(Val, _State) ->
    error({invalid_IndAudMediaDescriptor_multiStream, Val}).

enc_IndAudStreamDescriptor(#'IndAudStreamDescriptor'{streamID    = SID,
						     streamParms = Parms}, 
			   State) ->
%     d("enc_IndAudStreamDescriptor -> entry with"
%       "~n   SID:   ~p"
%       "~n   Parms: ~p", [SID, Parms]),
    [
     ?StreamToken,
     ?EQUAL,
     enc_StreamID(SID, State),
     ?LBRKT_INDENT(State),
     enc_IndAudStreamParms(Parms, ?INC_INDENT(State)),
     ?RBRKT_INDENT(State)
    ].
    
enc_IndAudEventBufferDescriptor(Val, State) 
  when record(Val, 'IndAudEventBufferDescriptor') ->
    #'IndAudEventBufferDescriptor'{eventName = EvName,
				   streamID  = ID} = Val, 
    [
     ?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(ID, State) ->
    [
     ?LBRKT_INDENT(State),
     enc_eventStream(ID, ?INC_INDENT(State)),
     ?RBRKT_INDENT(State)
    ].