megaco_text_mini_parser.hrl

OTP是开放电信平台的简称

% 				 extraInfo        = PP#'PropertyParm'.extraInfo},
%             do_merge_signalRequest(Sig, T, [SP | SPL]);
%         _ ->
%             return_error(0, {bad_sigParm, H})
%     end;
% do_merge_signalRequest(Sig, [], SPL) ->
%     Sig#'Signal'{sigParList = lists:reverse(SPL)} .

% %% eventStream       = StreamToken EQUAL StreamID
% %% eventOther        = eventParameterName parmValue
% select_stream_or_other("st", #'PropertyParm'{value = [Value]}) ->
%     {stream, ensure_uint16(Value)};
% select_stream_or_other("st", Value) ->
%     {stream, ensure_uint16(Value)};
% select_stream_or_other("stream", #'PropertyParm'{value = [Value]}) ->
%     {stream, ensure_uint16(Value)};
% select_stream_or_other("stream", Value) ->
%     {stream, ensure_uint16(Value)};
% select_stream_or_other(Name, #'PropertyParm'{value = Value}) ->
%     EP = #'EventParameter'{eventParameterName = Name,
%  			   value              = Value},
%     {other, EP}.

% ensure_eventDM({_TokenTag, Line, DMD}) 
%   when record(DMD, 'DigitMapDescriptor') ->
%     Name = DMD#'DigitMapDescriptor'.digitMapName,
%     Val  = DMD#'DigitMapDescriptor'.digitMapValue,
%     if
%         Name  == asn1_NOVALUE, Val /= asn1_NOVALUE ->
% 	    {'DigitMapValue', Start, Short, Long, Duration, Body} = Val,
% 	    DMV = #'DigitMapValue'{startTimer    = Start, 
% 				   shortTimer    = Short, 
% 				   longTimer     = Long, 
% 				   digitMapBody  = Body,
% 				   durationTimer = Duration},
%             {eventDM, {digitMapValue, DMV}};
%         Name  /= asn1_NOVALUE, Val == asn1_NOVALUE ->
%             {eventDM, {digitMapName, Name}};
%         true ->
%             return_error(Line, {bad_eventDM, DMD})
%     end.
    
% ensure_DMD({_TokenTag, _Line, DMD}) 
%   when record(DMD, 'DigitMapDescriptor') ->
%     Val2 = 
% 	case DMD#'DigitMapDescriptor'.digitMapValue of
% 	    %% Note that the values of the digitMapBody and durationTimers
% 	    %% are swapped by the scanner (this is done because of a 
% 	    %% problem in the flex scanner).
% 	    #'DigitMapValue'{durationTimer = Body,
% 			     digitMapBody  = Duration} = DMV ->
% 		%% Convert to version 1 DigitMapValue
% 		DMV#'DigitMapValue'{digitMapBody  = Body,
% 				    durationTimer = Duration};
% 	    Other ->
% 		Other
% 	end,
%     DMD#'DigitMapDescriptor'{digitMapValue = Val2}.


% merge_observed_event(ObservedEvents, EventName, TimeStamp) ->
%     StreamId = asn1_NOVALUE,
%     EPL = [],
%     do_merge_observed_event(ObservedEvents, EventName, TimeStamp, StreamId, EPL).

% do_merge_observed_event([{stream, StreamID} | T], EventName, TimeStamp, asn1_NOVALUE, EPL) ->
%     do_merge_observed_event(T, EventName, TimeStamp, StreamID, EPL);
% do_merge_observed_event([{other, PP} | T], EventName, TimeStamp, StreamID, EPL) ->
%     do_merge_observed_event(T, EventName, TimeStamp, StreamID, [PP | EPL]);
% do_merge_observed_event([], EventName, TimeStamp, StreamID, EPL) ->
%     #'ObservedEvent'{eventName    = EventName,
%                      timeNotation = TimeStamp,
%                      streamID     = StreamID,
%                      eventParList = lists:reverse(EPL)}.

% merge_eventSpec(OE) when record(OE, 'ObservedEvent'),
%                          OE#'ObservedEvent'.timeNotation == asn1_NOVALUE ->
%     #'EventSpec'{eventName     = OE#'ObservedEvent'.eventName,
%                  streamID      = OE#'ObservedEvent'.streamID,
%                  eventParList  = OE#'ObservedEvent'.eventParList};
% merge_eventSpec(OE) ->
%     return_error(0, {bad_event_spec, OE}).

% merge_eventParameters(Params) ->
%     StreamId = asn1_NOVALUE,
%     EPL      = [],
%     RA       = #'RequestedActions'{},
%     HasA     = no,
%     do_merge_eventParameters(Params, StreamId, EPL, RA, HasA) .
                                   
% do_merge_eventParameters([H | T], StreamId, EPL, RA, HasA) ->
%     case H of
%         keepActive when RA#'RequestedActions'.keepActive == asn1_NOVALUE ->
%             RA2 = RA#'RequestedActions'{keepActive = true},
%             do_merge_eventParameters(T, StreamId, EPL, RA2, yes);
%         {embed, SD, SED} when RA#'RequestedActions'.signalsDescriptor == asn1_NOVALUE ->
%             RA2 = RA#'RequestedActions'{signalsDescriptor = SD,
%                                           secondEvent       = SED},
%             do_merge_eventParameters(T, StreamId, EPL, RA2, yes);
%         {eventDM, DM} when RA#'RequestedActions'.eventDM == asn1_NOVALUE ->
%             RA2 = RA#'RequestedActions'{eventDM = DM},
%             do_merge_eventParameters(T, StreamId, EPL, RA2, yes);
%         {stream, NewStreamId} when StreamId == asn1_NOVALUE ->
%             do_merge_eventParameters(T, NewStreamId, EPL, RA, HasA);
%         {other, PP} when record(PP, 'PropertyParm') ->
%             EP = #'EventParameter'{eventParameterName = PP#'PropertyParm'.name,
%                                    value              = PP#'PropertyParm'.value,
% 				   extraInfo          = PP#'PropertyParm'.extraInfo},
%             do_merge_eventParameters(T, StreamId, [EP | EPL], RA, HasA);
%         {other, EP} when record(EP, 'EventParameter') ->
%             do_merge_eventParameters(T, StreamId, [EP | EPL], RA, HasA);
%         _ ->
%             return_error(0, {bad_eventParameter, H})
%     end;
% do_merge_eventParameters([], StreamId, EPL, RA, yes) ->
%     #'RequestedEvent'{streamID    = StreamId,
%                       eventAction = RA, 
%                       evParList   = lists:reverse(EPL)};
% do_merge_eventParameters([], StreamId, EPL, _RA, no) ->
%     #'RequestedEvent'{streamID    = StreamId,
%                       eventAction = asn1_NOVALUE, 
%                       evParList   = lists:reverse(EPL)}.

% merge_secondEventParameters(Params) ->
%     StreamId = asn1_NOVALUE,
%     EPL      = [],
%     SRA      = #'SecondRequestedActions'{},
%     HasA     = no,
%     do_merge_secondEventParameters(Params, StreamId, EPL, SRA, HasA) .
                                   
% do_merge_secondEventParameters([H | T], StreamId, EPL, SRA, HasA) ->
%     case H of
%         keepActive when SRA#'SecondRequestedActions'.keepActive == asn1_NOVALUE ->
%             SRA2 = SRA#'SecondRequestedActions'{keepActive = true},
%             do_merge_secondEventParameters(T, StreamId, EPL, SRA2, yes);
%         {second_embed, SD} when SRA#'SecondRequestedActions'.signalsDescriptor == asn1_NOVALUE ->
%             SRA2 = SRA#'SecondRequestedActions'{signalsDescriptor = SD},
%             do_merge_secondEventParameters(T, StreamId, EPL, SRA2, yes);
%         {eventDM, DM} when SRA#'SecondRequestedActions'.eventDM == asn1_NOVALUE ->
%             SRA2 = SRA#'SecondRequestedActions'{eventDM = DM},
%             do_merge_secondEventParameters(T, StreamId, EPL, SRA2, yes);
%         {stream, NewStreamId} when StreamId == asn1_NOVALUE ->
%             do_merge_secondEventParameters(T, NewStreamId, EPL, SRA, HasA);
%         {other, PP} when record(PP, 'PropertyParm') ->
%             EP = #'EventParameter'{eventParameterName = PP#'PropertyParm'.name,
%                                    value              = PP#'PropertyParm'.value,
% 				   extraInfo          = PP#'PropertyParm'.extraInfo},
%             do_merge_secondEventParameters(T, StreamId, [EP | EPL], SRA, HasA);
%         {other, EP} when record(EP, 'EventParameter') ->
%             do_merge_secondEventParameters(T, StreamId, [EP | EPL], SRA, HasA);
%         _ ->
%             return_error(0, {bad_secondEventParameter, H})
%     end;
% do_merge_secondEventParameters([], StreamId, EPL, SRA, yes) ->
%     #'SecondRequestedEvent'{streamID    = StreamId,
%                             eventAction = SRA, 
%                             evParList   = lists:reverse(EPL)};
% do_merge_secondEventParameters([], StreamId, EPL, _SRA, no) ->
%     #'SecondRequestedEvent'{streamID    = StreamId,
%                             eventAction = asn1_NOVALUE, 
%                             evParList   = lists:reverse(EPL)}.

% %% terminationID     = "ROOT" / pathName / "$" / "*"
% %% Total length of pathName must not exceed 64 chars.
% %% pathName          = ["*"] NAME *("/" / "*"/ ALPHA / DIGIT /"_" / "$" )
% %%                     ["@" pathDomainName ]
% %% ABNF allows two or more consecutive "." although it is meaningless
% %% in a path domain name.
% %% pathDomainName    = (ALPHA / DIGIT / "*" )
% %%                        *63(ALPHA / DIGIT / "-" / "*" / ".")
% ensure_terminationID({safeToken, _Line, LowerText}) ->
%     %% terminationID     = "ROOT" / pathName / "$" / "*"
%     decode_term_id(LowerText, false, [], []).

% decode_term_id([H | T], Wild, Id, Component) ->
%     case H of
%         $/ -> decode_term_id(T, Wild, [lists:reverse(Component) | Id], []);
%         $* -> decode_term_id(T, true, Id, [?megaco_all    | Component]);
%         $$ -> decode_term_id(T, true, Id, [?megaco_choose | Component]);
%         _  -> decode_term_id(T, Wild, Id, [H | Component])
%     end;
% decode_term_id([], Wild, Id, Component) ->
%     Id2 = [lists:reverse(Component) | Id],
%     #megaco_term_id{contains_wildcards = Wild, id = lists:reverse(Id2)}.
            
ensure_pathName({_TokenTag, _Line, Text}) ->
    Text.  %% BUGBUG: ensure values

%% TimeStamp            = Date "T" Time ; per ISO 8601:1988
%% Date                 = 8(DIGIT) ; Date = yyyymmdd
%% Time                 = 8(DIGIT) ; Time = hhmmssss
% ensure_timeStamp({'TimeStampToken', Line, Text}) ->
%     case string:tokens(Text, [$T, $t]) of
%         [Date, Time] ->
%             #'TimeNotation'{date = Date, time = Time};
%         _ ->
%             return_error(Line, {bad_timeStamp, Text})
%     end.

% ensure_transactionID(TransId) ->
%     ensure_uint32(TransId).

% %% transactionAck       = transactionID / (transactionID "-" transactionID)
% ensure_transactionAck({safeToken, _Line, Text}) ->
%     case string:tokens(Text, [$-]) of
%         [Id] ->
%             #'TransactionAck'{firstAck = ensure_transactionID(Id)};
%         [Id, Id2] ->
%             #'TransactionAck'{firstAck = ensure_transactionID(Id),
% 			      lastAck  = ensure_transactionID(Id2)}
%     end.

% merge_action_requests(CtxId, Items) ->
%     CtxReq      = #'ContextRequest'{},
%     CtxAuditReq = asn1_NOVALUE, 
%     CmdReq      = [],
%     TopReq      = [],
%     do_merge_action_requests(CtxId, CtxReq, CtxAuditReq, CmdReq, TopReq, Items).

% do_merge_action_requests(CtxId, CtxReq, CtxAuditReq, CmdReq, TopReq, [H | T]) ->
%     case H of
%         _ when record(H, 'CommandRequest') ->
%             do_merge_action_requests(CtxId, CtxReq, CtxAuditReq, [H | CmdReq], TopReq, T);

%         {priority, Int} when CtxReq#'ContextRequest'.priority == asn1_NOVALUE ->
%             CtxReq2 = CtxReq#'ContextRequest'{priority = Int},
%             do_merge_action_requests(CtxId, CtxReq2, CtxAuditReq, CmdReq, 
% 				     TopReq, T);
%         {emergency, Bool} when CtxReq#'ContextRequest'.emergency == asn1_NOVALUE ->
%             CtxReq2 = CtxReq#'ContextRequest'{emergency = Bool},
%             do_merge_action_requests(CtxId, CtxReq2, CtxAuditReq, CmdReq, 
% 				     TopReq, T);
%         {topology, Desc} ->
%             TopReq2 = Desc ++ TopReq, %% OTP-4088
%             do_merge_action_requests(CtxId, CtxReq, CtxAuditReq, CmdReq, 
% 				     TopReq2, T);

% 	{contextAudit, CAs} ->
% 	    CtxAuditReq2 = merge_context_attr_audit_request(CtxAuditReq, CAs),
% 	    do_merge_action_requests(CtxId, CtxReq, CtxAuditReq2, CmdReq, 
% 				     TopReq, T)
	    
%     end;
% do_merge_action_requests(CtxId, CtxReq, CtxAuditReq, CmdReq, TopReq, []) ->
%     #'ActionRequest'{contextId           = CtxId,
%                      contextRequest      = strip_contextRequest(CtxReq, TopReq),
%                      contextAttrAuditReq = strip_contextAttrAuditRequest(CtxAuditReq),
%                      commandRequests     = lists:reverse(CmdReq)}.


% merge_context_attr_audit_request(asn1_NOVALUE, CAs) ->
%     merge_context_attr_audit_request(#'ContextAttrAuditRequest'{}, CAs);
% merge_context_attr_audit_request(CAAR, [H|T]) ->
%     CAAR2 = 
% 	case H of
% 	    priorityAudit when CAAR#'ContextAttrAuditRequest'.priority == asn1_NOVALUE ->
% 		CAAR#'ContextAttrAuditRequest'{priority = 'NULL'};

% 	    priorityAudit ->
% 		Prio = CAAR#'ContextAttrAuditRequest'.priority,
% 		exit({only_once, priorityAudit, Prio});

% 	    emergencyAudit when CAAR#'ContextAttrAuditRequest'.emergency == asn1_NOVALUE ->
% 		CAAR#'ContextAttrAuditRequest'{emergency = 'NULL'};

% 	    emergencyAudit ->
% 		Em = CAAR#'ContextAttrAuditRequest'.emergency,
% 		exit({only_once, emergencyAudit, Em});

% 	    topologyAudit when CAAR#'ContextAttrAuditRequest'.topology == asn1_NOVALUE ->
% 		CAAR#'ContextAttrAuditRequest'{topology = 'NULL'};
	    
% 	    topologyAudit ->
% 		Top = CAAR#'ContextAttrAuditRequest'.topology,
% 		exit({only_once, topologyAudit, Top})

%     end,
%     merge_context_attr_audit_request(CAAR2, T);
% merge_context_attr_audit_request(CAAR, []) ->
%     CAAR.

% %% OTP-5085: 
% %% In order to solve a problem in the parser, the error descriptor
% %% has been put last in the non-empty commandReplyList, if it is not 
% %% asn1_NOVALUE
% merge_action_reply(ReplyList) ->
%     CtxReq  = #'ContextRequest'{},
%     TopReq  = [],
%     CmdList = [],
%     case lists:reverse(ReplyList) of
% 	[ED|RL2] when record(ED, 'ErrorDescriptor') ->
% 	    AR = do_merge_action_reply(lists:reverse(RL2), 
% 				       CtxReq, TopReq, CmdList),
% 	    AR#'ActionReply'{errorDescriptor = ED};
% 	_ ->
% 	    do_merge_action_reply(ReplyList, CtxReq, TopReq, CmdList)
%     end.

% do_merge_action_reply([H | T], CtxReq, TopReq, CmdList) ->
%     case H of
%         {command, Cmd} ->
%             do_merge_action_reply(T, CtxReq, TopReq, [Cmd | CmdList]);
%         {context, Ctx} ->
%             case Ctx of
%                 {priority, Int} when CtxReq#'ContextRequest'.priority == asn1_NOVALUE ->
%                     CtxReq2 = CtxReq#'ContextRequest'{priority = Int},
%                     do_merge_action_reply(T, CtxReq2, TopReq, CmdList);
%                 {emergency, Bool} when CtxReq#'ContextRequest'.emergency == asn1_NOVALUE ->
%                     CtxReq2 = CtxReq#'ContextRequest'{emergency = Bool},
%                     do_merge_action_reply(T, CtxReq2, TopReq, CmdList);
%                 {topology, Desc} ->