megaco_text_gen_v3.hrl

来自「OTP是开放电信平台的简称」· HRL 代码 · 共 2,218 行 · 第 1/5 页

     ?LBRKT,
     case Val#'ErrorDescriptor'.errorText of
	 asn1_NOVALUE ->
	     [];
	 ErrorText ->
	     enc_ErrorText(ErrorText, State)
     end,
     ?RBRKT
    ].

enc_ErrorCode({'ErrorCode',Val}, State)->
    enc_ErrorCode(Val, State);
enc_ErrorCode(Val, State) ->
    enc_DIGIT(Val, State, 0, 999).

enc_ErrorText({'ErrorText',Val}, State) ->
    enc_ErrorText(Val, State);
enc_ErrorText(Val, State)  ->
    enc_QUOTED_STRING(Val, State).

enc_ContextID({'ContextID',Val}, State) ->
    enc_ContextID(Val, State);
enc_ContextID(Val, State) ->
    case Val of
	?megaco_all_context_id    -> $*;
	?megaco_null_context_id   -> $-;
	?megaco_choose_context_id -> $$;
	Int when integer(Int) -> enc_UINT32(Int, State)
    end.

enc_ActionRequest(Bin, _State) when binary(Bin) ->
    [Bin]; %% Already encoded...
enc_ActionRequest(Val, State)
     when record(Val, 'ActionRequest') ->
    [
     ?CtxToken,
     ?EQUAL,
     enc_ContextID(Val#'ActionRequest'.contextId, State),
     ?LBRKT_INDENT(State),
     enc_list([{[Val#'ActionRequest'.contextRequest],
		fun enc_ContextRequest/2},
	       {[Val#'ActionRequest'.contextAttrAuditReq],
		fun enc_ContextAttrAuditRequest/2},
	       {Val#'ActionRequest'.commandRequests,
		fun enc_CommandRequest/2}],
	      ?INC_INDENT(State)),
     ?RBRKT_INDENT(State)
    ].

%% OTP-5085
enc_ActionReply(#'ActionReply'{contextId       = Id,
			       errorDescriptor = ED,
			       contextReply    = CtxRep,
			       commandReply    = CmdRep}, 
		State) ->
%     d("enc_ActionReply -> entry with"
%       "~n   Id:     ~p"
%       "~n   ED:     ~p"
%       "~n   CtxRep: ~p"
%       "~n   CmdRep: ~p", [Id, ED, CtxRep, CmdRep]),
    [
     ?CtxToken,
     ?EQUAL,
     enc_ContextID(Id, State),
     ?LBRKT_INDENT(State),
     do_enc_ActionReply(ED, CtxRep, CmdRep, State),
     ?RBRKT_INDENT(State)
    ].

do_enc_ActionReply(asn1_NOVALUE, CtxRep, [], State) 
  when CtxRep =/= asn1_NOVALUE ->
%     d("do_enc_ActionReply -> entry with"
%       "~n   CtxRep: ~p", [CtxRep]),
    [
     enc_ContextRequest(CtxRep, ?INC_INDENT(State))
    ];
do_enc_ActionReply(asn1_NOVALUE, CtxRep, CmdRep, State) 
  when CtxRep =/= asn1_NOVALUE, CmdRep =/= [] ->
%     d("do_enc_ActionReply -> entry with"
%       "~n   CtxRep: ~p"
%       "~n   CmdRep: ~p", [CtxRep, CmdRep]),
    [
     enc_ContextRequest(CtxRep, ?INC_INDENT(State)),
     ?COMMA_INDENT(?INC_INDENT(State)), 
     enc_list([{CmdRep, fun enc_CommandReply/2}],
	      ?INC_INDENT(State))
    ];
do_enc_ActionReply(asn1_NOVALUE, asn1_NOVALUE, CmdRep, State) 
  when CmdRep =/= [] ->
%     d("do_enc_ActionReply -> entry with"
%       "~n   CmdRep: ~p", [CmdRep]),
    [
     enc_list([{CmdRep, fun enc_CommandReply/2}],
	      ?INC_INDENT(State))
    ];
do_enc_ActionReply(ED, CtxRep, [], State) 
  when ED =/= asn1_NOVALUE, CtxRep =/= asn1_NOVALUE ->
%     d("do_enc_ActionReply -> entry with"
%       "~n   ED:     ~p"
%       "~n   CtxRep: ~p", [ED, CtxRep]),
    [
     enc_ContextRequest(CtxRep, ?INC_INDENT(State)),
     ?COMMA_INDENT(?INC_INDENT(State)), 
     enc_list([{[ED], fun enc_ErrorDescriptor/2}], % Indention cosmetics
 	      ?INC_INDENT(State))
    ];
do_enc_ActionReply(ED, asn1_NOVALUE, CmdRep, State) 
  when ED =/= asn1_NOVALUE, CmdRep =/= [] ->
%     d("do_enc_ActionReply -> entry with"
%       "~n   ED:     ~p"
%       "~n   CmdRep: ~p", [ED, CmdRep]),
    [
     enc_list([{CmdRep, fun enc_CommandReply/2},
	       {[ED],   fun enc_ErrorDescriptor/2}], % Indention cosmetics
 	      ?INC_INDENT(State))
    ];
do_enc_ActionReply(ED, CtxRep, CmdRep, State) 
  when ED =/= asn1_NOVALUE, CtxRep =/= asn1_NOVALUE, CmdRep =/= [] ->
%     d("do_enc_ActionReply -> entry with"
%       "~n   ED:     ~p"
%       "~n   CtxRep: ~p"
%       "~n   CmdRep: ~p", [ED, CtxRep, CmdRep]),
    [
     enc_ContextRequest(CtxRep, ?INC_INDENT(State)),
     ?COMMA_INDENT(?INC_INDENT(State)), 
     enc_list([{CmdRep, fun enc_CommandReply/2},
	       {[ED],   fun enc_ErrorDescriptor/2}], % Indention cosmetics
 	      ?INC_INDENT(State))
    ];
do_enc_ActionReply(ED, asn1_NOVALUE, [], State) 
  when ED =/= asn1_NOVALUE ->
%     d("do_enc_ActionReply -> entry with"
%       "~n   ED:     ~p", [ED]),
    [
     enc_ErrorDescriptor(ED, ?INC_INDENT(State))
    ].


enc_ContextRequest_priority(asn1_NOVALUE, _State) ->
    {[], dummy};
enc_ContextRequest_priority(Val, _State) ->
    {[Val], fun(X,S) -> [?PriorityToken,?EQUAL,enc_UINT16(X, S)] end}.

enc_ContextRequest_emergency(asn1_NOVALUE, _State) ->
    {[], dummy};
enc_ContextRequest_emergency(true, _State) ->
    {[?EmergencyToken], fun(Elem, _) -> Elem end};
enc_ContextRequest_emergency(false, _State) ->
    {[?EmergencyOffToken], fun(Elem, _) -> Elem end}.

enc_ContextRequest_topologyReq(asn1_NOVALUE, _State) ->
    {[], dummy};
enc_ContextRequest_topologyReq({'ContextRequest_topologyReq', 
				asn1_NOVALUE}, _State) ->
    {[], dummy};
enc_ContextRequest_topologyReq({'ContextRequest_topologyReq', 
				List}, _State) ->
    {List, fun enc_TopologyRequest/2};
enc_ContextRequest_topologyReq(List, _State) ->
    {[List], fun enc_TopologyRequest/2}.

enc_ContextRequest_iepsCallind(asn1_NOVALUE, _State) ->
    {[], dummy};
enc_ContextRequest_iepsCallind(false, _State) ->
    {[], dummy};
% enc_ContextRequest_iepsCallind(false, _State) ->
%     {[?IEPS_XXXX_Token], fun(Elem, _) -> Elem end};
enc_ContextRequest_iepsCallind(true, _State) ->
    {[?IEPSToken], fun(Elem, _) -> Elem end}.

enc_ContextRequest_contextProp(asn1_NOVALUE, _State) ->
    {[], dummy};
enc_ContextRequest_contextProp([], _State) ->
    {[], dummy};
enc_ContextRequest_contextProp([PP], _State) ->
    {[PP], fun enc_PropertyParm/2};
enc_ContextRequest_contextProp(PPs, _State) when list(PPs) ->
    error({at_most_one_contextProp, PPs}).

enc_ContextRequest(asn1_NOVALUE, _State) ->
    [];
enc_ContextRequest(#'ContextRequest'{priority    = asn1_NOVALUE, 
				     emergency   = asn1_NOVALUE,
				     topologyReq = asn1_NOVALUE,
				     iepsCallind = asn1_NOVALUE,
				     contextProp = asn1_NOVALUE}, _State) ->
    [];
enc_ContextRequest(#'ContextRequest'{priority    = asn1_NOVALUE, 
				     emergency   = asn1_NOVALUE,
				     topologyReq = [],
				     iepsCallind = asn1_NOVALUE,
				     contextProp = []}, _State) ->
    [];
enc_ContextRequest(#'ContextRequest'{priority    = Prio, 
				     emergency   = Em,
				     topologyReq = TR,
				     iepsCallind = Ieps,
				     contextProp = CP}, State) ->
    [
     ?ContextAttrToken,
     ?LBRKT_INDENT(State),
     enc_list([enc_ContextRequest_priority(Prio, State), 
	       enc_ContextRequest_emergency(Em, State), 
	       enc_ContextRequest_topologyReq(TR, State), 
	       enc_ContextRequest_iepsCallind(Ieps, State), 
	       enc_ContextRequest_contextProp(CP, State)],
	      ?INC_INDENT(State)),
     ?RBRKT_INDENT(State)
    ].

enc_ContextAttrAuditRequest(
  #'ContextAttrAuditRequest'{topology       = asn1_NOVALUE,
			     emergency      = asn1_NOVALUE,
			     priority       = asn1_NOVALUE,
			     iepsCallind    = asn1_NOVALUE,
			     contextPropAud = asn1_NOVALUE}, _State) ->
    [];
enc_ContextAttrAuditRequest(
  #'ContextAttrAuditRequest'{topology       = asn1_NOVALUE,
			     emergency      = asn1_NOVALUE,
			     priority       = asn1_NOVALUE,
			     iepsCallind    = asn1_NOVALUE,
			     contextPropAud = []}, _State) ->
    [];
enc_ContextAttrAuditRequest(CAAR, State) ->
    [
     ?ContextAuditToken,
     ?LBRKT_INDENT(State),
     enc_IndAudContextAttrDescriptor(CAAR, ?INC_INDENT(State)),
     ?RBRKT_INDENT(State)
    ].

enc_IndAudContextAttrDescriptor(
  #'ContextAttrAuditRequest'{topology       = Top,
			     emergency      = Em,
			     priority       = Prio,
			     iepsCallind    = Ieps,
			     contextPropAud = CPA}, State) ->
    [
     ?ContextAttrToken,
     ?LBRKT_INDENT(State),
     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(Val, State)
  when record(Val, 'CommandRequest') ->
%     d("enc_CommandRequest -> entry with"
%       "~n   Val: ~p", [Val]),
    [
     case Val#'CommandRequest'.optional of
	 asn1_NOVALUE ->
	     [];
	 'NULL' ->
	     "O-"
     end,
     case Val#'CommandRequest'.wildcardReturn of
	 asn1_NOVALUE ->
	     [];
	 'NULL' ->
	     "W-"
     end,
     enc_Command(Val#'CommandRequest'.command, 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 = Dir}, State) ->
    [
     enc_TerminationID(From, State),
     ?COMMA_INDENT(State),
     enc_TerminationID(To, State),
     ?COMMA_INDENT(State),
     enc_TopologyDirection(Dir, State)
    ].

enc_TopologyDirection(bothway, _State) ->
    ?BothwayToken;
enc_TopologyDirection(isolate, _State) -> 
    ?IsolateToken;
enc_TopologyDirection(oneway, _State) ->  
    ?OnewayToken;
enc_TopologyDirection(Top, _State) ->
    error({illegal_TopologyDirection, Top}).

enc_AmmRequest(Val, State)
  when record(Val, 'AmmRequest') ->
%     d("enc_AmmRequest -> entry with"
%       "~n   Val: ~p", [Val]),
    [
     %% Assume that Token is added elsewhere
     ?EQUAL,
     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]),
    [