megaco_text_gen_prev3c.hrl

OTP是开放电信平台的简称

%%      enc_list([{[Top],  fun('NULL', _) -> ?TopologyToken end},
%% 	       {[Em],   fun('NULL', _) -> ?EmergencyToken end},
%% 	       {[Prio], fun('NULL', _) -> ?PriorityToken end},
%% 	       {[Ieps], fun('NULL', _) -> ?IEPSToken end},
%% 	       {CPA,    fun enc_IndAudPropertyParm/2}],
%% 	      ?INC_INDENT(State)),
%%      ?RBRKT_INDENT(State)
%%     ].

enc_CommandRequest(#'CommandRequest'{optional       = asn1_NOVALUE,
				     wildcardReturn = asn1_NOVALUE,
				     command        = Cmd}, State) ->
    [
     enc_Command(Cmd, State)
    ];
enc_CommandRequest(#'CommandRequest'{optional       = 'NULL',
				     wildcardReturn = asn1_NOVALUE,
				     command        = Cmd}, State) ->
    [
     "O-",
     enc_Command(Cmd, State)
    ]; 
enc_CommandRequest(#'CommandRequest'{optional       = asn1_NOVALUE,
				     wildcardReturn = 'NULL',
				     command        = Cmd}, State) ->
    [
     "W-",
     enc_Command(Cmd, State)
    ]; 
enc_CommandRequest(#'CommandRequest'{optional       = 'NULL',
				     wildcardReturn = 'NULL',
				     command        = Cmd}, State) ->
    [
     "O-",
     "W-",
     enc_Command(Cmd, State)
    ]. 

enc_Command({'Command',Val}, State) ->
    enc_Command(Val, State);
enc_Command({Tag, Val}, State) ->
%%     d("enc_Command -> entry with"
%%       "~n   Tag: ~p"
%%       "~n   Val: ~p", [Tag, Val]),
    case Tag of
	addReq ->
	    [?AddToken, enc_AmmRequest(Val, State)];
	moveReq ->
	    [?MoveToken, enc_AmmRequest(Val, State)];
	modReq ->
	    [?ModifyToken, enc_AmmRequest(Val, State)];
	subtractReq ->
	    [?SubtractToken, enc_SubtractRequest(Val, State)];
	auditCapRequest ->
	    [?AuditCapToken, enc_AuditRequest(Val, State)];
	auditValueRequest ->
	    [?AuditValueToken, enc_AuditRequest(Val, State)];
	notifyReq ->
	    [?NotifyToken, enc_NotifyRequest(Val, State)];
	serviceChangeReq ->
	    [?ServiceChangeToken, enc_ServiceChangeRequest(Val, State)];
	_ ->
	    error({invalid_Command_tag, Tag})
    end.

enc_CommandReply({'CommandReply',Val}, State) ->
    enc_CommandReply(Val, State);
enc_CommandReply({Tag, Val}, State) ->
%%     d("enc_CommandReply -> entry with"
%%       "~n   Tag: ~p"
%%       "~n   Val: ~p", [Tag, Val]),
    case Tag of
	addReply ->
	    [?AddToken, enc_AmmsReply(Val, State)];
	moveReply ->
	    [?MoveToken, enc_AmmsReply(Val, State)];
	modReply ->
	    [?ModifyToken, enc_AmmsReply(Val, State)];
	subtractReply ->
	    [?SubtractToken, enc_AmmsReply(Val, State)];
	auditCapReply ->
	    [?AuditCapToken, enc_AuditReply(Val, State)];
	auditValueReply ->
	    [?AuditValueToken, enc_AuditReply(Val, State)];
	notifyReply ->
	    [?NotifyToken, enc_NotifyReply(Val, State)];
	serviceChangeReply ->
	    [?ServiceChangeToken, enc_ServiceChangeReply(Val, State)];
	_ ->
	    error({invalid_CommandReply_tag, Tag})
     end.

enc_TopologyRequest(Val, State)
  when list(Val) ->
    [
     ?TopologyToken,
     ?LBRKT_INDENT(State),
     enc_list([{Val, fun enc_TopologyRequest1/2}], ?INC_INDENT(State)),
     ?RBRKT_INDENT(State)
    ].

enc_TopologyRequest1(
  #'TopologyRequest'{terminationFrom            = From,
		     terminationTo              = To,
		     topologyDirection          = TD,
 		     streamID                   = asn1_NOVALUE, % OPTIONAL
 		     topologyDirectionExtension = asn1_NOVALUE  % OPTIONAL
		    }, State) ->
    [
     enc_TerminationID(From, State),
     ?COMMA_INDENT(State),
     enc_TerminationID(To, State),
     ?COMMA_INDENT(State),
     enc_TopologyDirection(TD, State)
    ];
enc_TopologyRequest1(
  #'TopologyRequest'{terminationFrom            = From,
		     terminationTo              = To,
		     topologyDirection          = TD,
 		     streamID                   = SID,            % OPTIONAL
 		     topologyDirectionExtension = asn1_NOVALUE},  % OPTIONAL
  State) when (SID =/= asn1_NOVALUE) ->
    [
     enc_TerminationID(From, State),
     ?COMMA_INDENT(State),
     enc_TerminationID(To, State),
     ?COMMA_INDENT(State),
     enc_TopologyDirection(TD, State),
     ?COMMA_INDENT(State),
     enc_StreamID(SID, State)
    ];
enc_TopologyRequest1(
  #'TopologyRequest'{terminationFrom            = From,
		     terminationTo              = To,
		     topologyDirection          = TD,
 		     streamID                   = asn1_NOVALUE, % OPTIONAL
 		     topologyDirectionExtension = TDE},         % OPTIONAL
  State) when (TDE =/= asn1_NOVALUE) ->
    [
     enc_TerminationID(From, State),
     ?COMMA_INDENT(State),
     enc_TerminationID(To, State),
     ?COMMA_INDENT(State),
     enc_TopologyDirection(TD, State),
     ?COMMA_INDENT(State),
     enc_TopologyDirectionExtension(TDE, State)
    ];
enc_TopologyRequest1(
  #'TopologyRequest'{terminationFrom            = From,
		     terminationTo              = To,
		     topologyDirection          = TD,
 		     streamID                   = SID,   % OPTIONAL
 		     topologyDirectionExtension = TDE},  % OPTIONAL
  State) when (SID =/= asn1_NOVALUE) and (TDE =/= asn1_NOVALUE) ->
    [
     enc_TerminationID(From, State),
     ?COMMA_INDENT(State),
     enc_TerminationID(To, State),
     ?COMMA_INDENT(State),
     enc_TopologyDirection(TD, State),
     ?COMMA_INDENT(State),
     enc_StreamID(SID, State),
     ?COMMA_INDENT(State),
     enc_TopologyDirectionExtension(TDE, State)
    ].

enc_TopologyDirection(bothway, _State) ->
    ?BothwayToken;
enc_TopologyDirection(isolate, _State) -> 
    ?IsolateToken;
enc_TopologyDirection(oneway, _State) ->  
    ?OnewayToken.

enc_TopologyDirectionExtension(onewayexternal, _State) ->  
    ?OnewayExternalToken;
enc_TopologyDirectionExtension(onewayboth, _State) ->  
    ?OnewayBothToken.

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



enc_AmmRequest(#'AmmRequest'{terminationID = TIDs,
			     descriptors   = Ds}, State) ->
    [
     %% Assume that Token is added elsewhere
     ?EQUAL,
     enc_termIDList(TIDs, State),
     enc_opt_brackets(
       enc_list([{Ds, fun enc_ammDescriptor/2}], ?INC_INDENT(State)),
       State)
    ].

enc_ammDescriptor({Tag, Desc}, State) ->
    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    = TIDs, 
			   terminationAudit = asn1_NOVALUE}, State) ->
    [
     ?EQUAL,
     enc_termIDList(TIDs, State)
    ];
enc_AmmsReply(#'AmmsReply'{terminationID    = TIDs, 
			   terminationAudit = []}, State) ->
    [
     ?EQUAL,
     enc_termIDList(TIDs, State)
    ];
enc_AmmsReply(#'AmmsReply'{terminationID    = TIDs, 
			   terminationAudit = Res}, State) ->
    [
     ?EQUAL,
     enc_termIDList(TIDs, State),
     case lists:flatten(enc_TerminationAudit(Res, ?INC_INDENT(State))) of
	 [] ->
	     [];
	 L ->
	     [
	      ?LBRKT_INDENT(State), 
	      L,
	      ?RBRKT_INDENT(State)
	     ]
     end
    ].

enc_SubtractRequest(#'SubtractRequest'{terminationID   = TIDs,
				       auditDescriptor = asn1_NOVALUE}, 
		    State) ->
    [
     %% Assume that Token is added elsewhere
     ?EQUAL,
     enc_termIDList(TIDs, State)
    ];
enc_SubtractRequest(#'SubtractRequest'{terminationID   = TIDs,
				       auditDescriptor = AD}, 
		    State) ->
    [
     %% Assume that Token is added elsewhere
     ?EQUAL,
     enc_termIDList(TIDs, State),
     ?LBRKT_INDENT(State),
     enc_AuditDescriptor(AD, ?INC_INDENT(State)),
     ?RBRKT_INDENT(State)
    ].    

enc_AuditRequest(#'AuditRequest'{terminationID     = TID,
				 auditDescriptor   = asn1_NOVALUE,
				 terminationIDList = asn1_NOVALUE}, State) ->
    [
     %% Assume that Token is added elsewhere
     ?EQUAL,
     enc_termIDList([TID], State)
    ];
enc_AuditRequest(#'AuditRequest'{terminationID     = TID,
				 auditDescriptor   = asn1_NOVALUE,
				 terminationIDList = [TID|_] = TIDList}, 
		 State) ->
    [
     %% Assume that Token is added elsewhere
     ?EQUAL,
     enc_termIDList(TIDList, State)
    ];
enc_AuditRequest(#'AuditRequest'{terminationID     = TID,
				 auditDescriptor   = asn1_NOVALUE,
				 terminationIDList = TIDList}, 
		 _State) ->
    error({invalid_terminationID, TID, TIDList});
enc_AuditRequest(#'AuditRequest'{terminationID     = TID,
				 auditDescriptor   = AD,
				 terminationIDList = asn1_NOVALUE}, State) ->
    [
     %% Assume that Token is added elsewhere
     ?EQUAL,
     enc_termIDList([TID], State),
     ?LBRKT_INDENT(State),
     enc_AuditDescriptor(AD, ?INC_INDENT(State)),
     ?RBRKT_INDENT(State)
    ];
enc_AuditRequest(#'AuditRequest'{terminationID     = TID,
				 auditDescriptor   = AD,
				 terminationIDList = [TID|_] = TIDList}, 
		 State) ->
    [
     %% Assume that Token is added elsewhere
     ?EQUAL,
     enc_termIDList(TIDList, State),
     ?LBRKT_INDENT(State),
     enc_AuditDescriptor(AD, ?INC_INDENT(State)),
     ?RBRKT_INDENT(State)
    ];
enc_AuditRequest(#'AuditRequest'{terminationID     = TID,
				 auditDescriptor   = _AD,
				 terminationIDList = TIDList}, 
		 _State) ->
    error({invalid_terminationID, TID, TIDList}).

%% 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) ->
%%     d("enc_AuditReply -> entry with"
%%       "~n   Tag: ~p"
%%       "~n   Val: ~p", [Tag, Val]),
    case Tag of
	contextAuditResult ->
	    [
	     ?EQUAL,
	     ?CtxToken,
	     enc_TerminationIDList(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});
	auditResultTermList ->
	    enc_TermListAuditResult(Val, State);
	_ ->
	    error({invalid_AuditReply_tag, Tag})
    end.

%% This is actually the same as AuditResult with the exception
%% that instead of terminationID we have terminationIDList.
enc_TermListAuditResult(
  #'TermListAuditResult'{terminationIDList      = TIDList,
			 terminationAuditResult = asn1_NOVALUE}, State) ->
%%     d("enc_TermListAuditResult -> entry with"
%%       "~n   TIDList: ~p", [TIDList]),
    [
     ?EQUAL,
     enc_termIDList(TIDList, State)
    ];
enc_TermListAuditResult(
  #'TermListAuditResult'{terminationIDList      = TIDList,
			 terminationAuditResult = []}, State) ->
%%     d("enc_TermListAuditResult -> entry with"
%%       "~n   TIDList: ~p", [TIDList]),
    [
     ?EQUAL,
     enc_termIDList(TIDList, State)
    ];
enc_TermListAuditResult(
  #'TermListAuditResult'{terminationIDList      = TIDList,
			 terminationAuditResult = TAR}, State) ->
%%     d("enc_TermListAuditResult -> entry with"
%%       "~n   TIDList: ~p"
%%       "~n   TAR:     ~p", [TIDList, TAR]),
    [
     ?EQUAL,
     enc_termIDList(TIDList, State),
     case lists:flatten(enc_TerminationAudit(TAR, ?INC_INDENT(State))) of
	 [] ->
	     [];
	 L ->
	     [
	      ?LBRKT_INDENT(State), 
	      L,
	      ?RBRKT_INDENT(State)
	     ]
     end
    ].

enc_auditOther(#'AuditResult'{terminationID          = TID,
			      terminationAuditResult = asn1_NOVALUE}, State) ->
    [
     ?EQUAL,
     enc_termIDList([TID], State)
    ];
enc_auditOther(#'AuditResult'{terminationID          = TID,
			      terminationAuditResult = []}, State) ->
    [
     ?EQUAL,
     enc_termIDList([TID], State)
    ];
enc_auditOther(#'AuditResult'{terminationID          = TID,
			      terminationAuditResult = Res}, State) ->
    [
     ?EQUAL,
     enc_termIDList([TID], 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,