megaco_text_mini_parser.hrl

OTP是开放电信平台的简称

% 	    Desc
%     end.

% ensure_indAudLocalParm(Token) ->
%     case Token of
% 	{safeToken, _Line, "mode"}          -> modeToken;
% 	{safeToken, _Line, "mo"}            -> modeToken;
% 	{safeToken, _Line, "reservedgroup"} -> reservedGroupToken;
% 	{safeToken, _Line, "rg"}            -> reservedGroupToken;
% 	{safeToken, _Line, "reservedvalue"} -> reservedValueToken;
% 	{safeToken, _Line, "rv"}            -> reservedValueToken;
% 	PkgdName                            -> {pkgdName,
% 						ensure_pkgdName(PkgdName)}
%     end.

% merge_indAudTerminationStateDescriptor({pkgdName, Val}) ->
%     PropParm = #'IndAudPropertyParm'{name = Val},
%     #'IndAudTerminationStateDescriptor'{propertyParms = [PropParm]};
% merge_indAudTerminationStateDescriptor(serviceStatesToken) ->
%     #'IndAudTerminationStateDescriptor'{serviceState = 'NULL'};
% merge_indAudTerminationStateDescriptor(bufferToken) ->
%     #'IndAudTerminationStateDescriptor'{eventBufferControl = 'NULL'}.


% merge_indAudEventBufferDescriptor(EventName, SpecParams) ->
%     IAEBD = #'IndAudEventBufferDescriptor'{eventName = EventName},
%     do_merge_indAudEventBufferDescriptor(SpecParams, IAEBD).

% do_merge_indAudEventBufferDescriptor(asn1_NOVALUE, IAEBD) ->
%     IAEBD;
% do_merge_indAudEventBufferDescriptor({streamID, StreamID}, IAEBD) ->
%     IAEBD#'IndAudEventBufferDescriptor'{streamID = StreamID};
% do_merge_indAudEventBufferDescriptor({eventParameterName, _Name} = EPN, 
% 				     IAEBD) ->
%     %% BUGBUG BUGBUG BUGBUG 
%     %% This is an ugly hack to allow the eventParamName which only
%     %% exists in the text encoding...
%     IAEBD#'IndAudEventBufferDescriptor'{streamID = EPN}.


% ensure_indAudSignalListParm(SIG) when record(SIG, 'Signal') ->
%     ensure_indAudSignal(SIG).

% ensure_indAudSignal(#'Signal'{signalName       = SignalName,
% 			      streamID         = asn1_NOVALUE, 
% 			      sigType          = asn1_NOVALUE, 
% 			      duration         = asn1_NOVALUE, 
% 			      notifyCompletion = asn1_NOVALUE, 
% 			      keepActive       = asn1_NOVALUE, 
% 			      sigParList       = []}) ->
%     #'IndAudSignal'{signalName = SignalName}.
    

% ensure_IADMD({_TokenTag, _Line, 
% 	      #'DigitMapDescriptor'{digitMapName  = Name,
% 				    digitMapValue = asn1_NOVALUE}}) ->
%     #'IndAudDigitMapDescriptor'{digitMapName = Name}.


% merge_indAudPackagesDescriptor(#'PackagesItem'{packageName    = N,
% 					       packageVersion = V}) ->
%     #'IndAudPackagesDescriptor'{packageName    = N,
% 				packageVersion = V}.


% ensure_indAudTerminationStateParm(Token) ->
%     case Token of
% 	{safeToken, _Line, "servicestates"} -> serviceStatesToken;
% 	{safeToken, _Line, "si"}            -> serviceStatesToken;
% 	{safeToken, _Line, "buffer"}        -> bufferToken;
% 	{safeToken, _Line, "bf"}            -> bufferToken;
% 	PkgdName                            -> {pkgdName,
% 						ensure_pkgdName(PkgdName)}
%     end.


% %% Types modified by v2:

% merge_auditDescriptor([]) ->
%     #'AuditDescriptor'{};
% merge_auditDescriptor(Tokens) when list(Tokens) ->
%     case lists:keysearch(terminationAudit, 1, Tokens) of
% 	{value, {terminationAudit, TA}} ->
% 	    case lists:keydelete(terminationAudit, 1, Tokens) of
% 		[] ->
% 		    #'AuditDescriptor'{auditPropertyToken = TA};
% 		AuditTokens ->
% 		    #'AuditDescriptor'{auditToken         = AuditTokens,
% 				       auditPropertyToken = TA}
% 	    end;
% 	false ->
% 	    #'AuditDescriptor'{auditToken = Tokens}
%     end;
% merge_auditDescriptor(_) ->
%     #'AuditDescriptor'{}.


% %% v2 - end



% merge_ServiceChangeParm(Parms) ->
%     Required = [serviceChangeReason, serviceChangeMethod],
%     merge_ServiceChangeParm(Parms, #'ServiceChangeParm'{}, Required).

% merge_ServiceChangeParm([], SCP, []) ->
%     SCP;

% merge_ServiceChangeParm([], _SCP, Required) ->
%     exit({missing_required_serviceChangeParm, Required});

% merge_ServiceChangeParm([{address, Val}|Parms], SCP0, Req) 
%   when SCP0#'ServiceChangeParm'.serviceChangeAddress == asn1_NOVALUE,
%        SCP0#'ServiceChangeParm'.serviceChangeMgcId == asn1_NOVALUE ->
%     SCP = SCP0#'ServiceChangeParm'{serviceChangeAddress = Val},
%     merge_ServiceChangeParm(Parms, SCP, Req);
% merge_ServiceChangeParm([{address, Val}|_Parms], SCP0, _Req) 
%   when SCP0#'ServiceChangeParm'.serviceChangeAddress == asn1_NOVALUE ->
%     MgcId = SCP0#'ServiceChangeParm'.serviceChangeMgcId,
%     exit({not_both_address_mgcid_serviceChangeParm, Val, MgcId});

% merge_ServiceChangeParm([{mgc_id, Val}|Parms], SCP0, Req) 
%   when SCP0#'ServiceChangeParm'.serviceChangeMgcId == asn1_NOVALUE,
%        SCP0#'ServiceChangeParm'.serviceChangeAddress == asn1_NOVALUE ->
%     SCP = SCP0#'ServiceChangeParm'{serviceChangeMgcId = Val},
%     merge_ServiceChangeParm(Parms, SCP, Req);
% merge_ServiceChangeParm([{mgc_id, Val}|_Parms], SCP0, _Req) 
%   when SCP0#'ServiceChangeParm'.serviceChangeMgcId == asn1_NOVALUE ->
%     Addr = SCP0#'ServiceChangeParm'.serviceChangeAddress,
%     exit({not_both_address_mgcid_serviceChangeParm, Val, Addr});

% merge_ServiceChangeParm([{profile, Val}|Parms], SCP0, Req) 
%   when SCP0#'ServiceChangeParm'.serviceChangeProfile == asn1_NOVALUE ->
%     SCP = SCP0#'ServiceChangeParm'{serviceChangeProfile = Val},
%     merge_ServiceChangeParm(Parms, SCP, Req);

% merge_ServiceChangeParm([{version, Val}|Parms], SCP0, Req) 
%   when SCP0#'ServiceChangeParm'.serviceChangeVersion == asn1_NOVALUE ->
%     SCP = SCP0#'ServiceChangeParm'{serviceChangeVersion = Val},
%     merge_ServiceChangeParm(Parms, SCP, Req);

% %% REQUIRED (i.e. no default value)
% merge_ServiceChangeParm([{reason, Val}|Parms], SCP0, Req0) 
%   when SCP0#'ServiceChangeParm'.serviceChangeReason == undefined ->
%     SCP = SCP0#'ServiceChangeParm'{serviceChangeReason = Val},
%     Req = lists:delete(serviceChangeReason, Req0),
%     merge_ServiceChangeParm(Parms, SCP, Req);

% merge_ServiceChangeParm([{delay, Val}|Parms], SCP0, Req) 
%   when SCP0#'ServiceChangeParm'.serviceChangeDelay == asn1_NOVALUE ->
%     SCP = SCP0#'ServiceChangeParm'{serviceChangeDelay = Val},
%     merge_ServiceChangeParm(Parms, SCP, Req);

% %% REQUIRED (i.e. no default value)
% merge_ServiceChangeParm([{method, Val}|Parms], SCP0, Req0) 
%   when SCP0#'ServiceChangeParm'.serviceChangeMethod == undefined ->
%     SCP = SCP0#'ServiceChangeParm'{serviceChangeMethod = Val},
%     Req = lists:delete(serviceChangeMethod, Req0),
%     merge_ServiceChangeParm(Parms, SCP, Req);

% merge_ServiceChangeParm([{time_stamp, Val}|Parms], SCP0, Req) 
%   when SCP0#'ServiceChangeParm'.timeStamp == asn1_NOVALUE ->
%     SCP = SCP0#'ServiceChangeParm'{timeStamp = Val},
%     merge_ServiceChangeParm(Parms, SCP, Req);

% merge_ServiceChangeParm([{extension, _Val}|Parms], SCP0, Req) ->
%     merge_ServiceChangeParm(Parms, SCP0, Req);

% merge_ServiceChangeParm([{audit_item, Val}|Parms], SCP0, Req) 
%   when SCP0#'ServiceChangeParm'.serviceChangeInfo == asn1_NOVALUE ->
%     SCI = #'AuditDescriptor'{auditToken = [Val]},
%     SCP = SCP0#'ServiceChangeParm'{serviceChangeInfo = SCI},
%     merge_ServiceChangeParm(Parms, SCP, Req);

% merge_ServiceChangeParm([{Tag, Val}|_Parms], SCP, _Req) ->
%     Val2 = 
% 	case Tag of
% 	    address -> 
% 		SCP#'ServiceChangeParm'.serviceChangeAddress;
% 	    mgc_id     -> 
% 		SCP#'ServiceChangeParm'.serviceChangeMgcId;
% 	    profile    -> 
% 		SCP#'ServiceChangeParm'.serviceChangeProfile;
% 	    version    -> 
% 		SCP#'ServiceChangeParm'.serviceChangeVersion;
% 	    reason     -> 
% 		SCP#'ServiceChangeParm'.serviceChangeReason;
% 	    delay      -> 
% 		SCP#'ServiceChangeParm'.serviceChangeDelay;
% 	    method     -> 
% 		SCP#'ServiceChangeParm'.serviceChangeMethod;
% 	    time_stamp -> 
% 		SCP#'ServiceChangeParm'.timeStamp;
% 	    audit_item -> 
% 		SCP#'ServiceChangeParm'.serviceChangeInfo
% 	end,
%     exit({at_most_once_serviceChangeParm, {Tag, Val, Val2}}).


% merge_ServiceChangeResParm(Parms) ->
%     merge_ServiceChangeResParm(Parms, #'ServiceChangeResParm'{}).

% merge_ServiceChangeResParm([], SCRP) ->
%     SCRP;
% merge_ServiceChangeResParm([{address, Val}|Parms], SCRP0) 
%   when SCRP0#'ServiceChangeResParm'.serviceChangeAddress == asn1_NOVALUE,
%        SCRP0#'ServiceChangeResParm'.serviceChangeMgcId == asn1_NOVALUE ->
%     SCRP = SCRP0#'ServiceChangeResParm'{serviceChangeAddress = Val},
%     merge_ServiceChangeResParm(Parms, SCRP);
% merge_ServiceChangeResParm([{address, Val}|_Parms], SCRP0) 
%   when SCRP0#'ServiceChangeResParm'.serviceChangeAddress == asn1_NOVALUE ->
%     MgcId = SCRP0#'ServiceChangeResParm'.serviceChangeMgcId,
%     exit({not_both_address_mgcid_servChgReplyParm, Val, MgcId});

% merge_ServiceChangeResParm([{mgc_id, Val}|Parms], SCRP0)
%   when SCRP0#'ServiceChangeResParm'.serviceChangeMgcId == asn1_NOVALUE,
%        SCRP0#'ServiceChangeResParm'.serviceChangeAddress == asn1_NOVALUE -> 
%     SCRP = SCRP0#'ServiceChangeResParm'{serviceChangeMgcId = Val},
%     merge_ServiceChangeResParm(Parms, SCRP);
% merge_ServiceChangeResParm([{mgc_id, Val}|_Parms], SCRP0)
%   when SCRP0#'ServiceChangeResParm'.serviceChangeMgcId == asn1_NOVALUE -> 
%     Addr = SCRP0#'ServiceChangeResParm'.serviceChangeAddress,
%     exit({not_both_address_mgcid_servChgReplyParm, Val, Addr});

% merge_ServiceChangeResParm([{profile, Val}|Parms], SCRP0)
%   when SCRP0#'ServiceChangeResParm'.serviceChangeProfile == asn1_NOVALUE ->
%     SCRP = SCRP0#'ServiceChangeResParm'{serviceChangeProfile = Val},
%     merge_ServiceChangeResParm(Parms, SCRP);

% merge_ServiceChangeResParm([{version, Val}|Parms], SCRP0)
%   when SCRP0#'ServiceChangeResParm'.serviceChangeVersion == asn1_NOVALUE ->
%     SCRP = SCRP0#'ServiceChangeResParm'{serviceChangeVersion = Val},
%     merge_ServiceChangeResParm(Parms, SCRP);

% merge_ServiceChangeResParm([{time_stamp, Val}|Parms], SCRP0)
%   when SCRP0#'ServiceChangeResParm'.timeStamp == asn1_NOVALUE ->
%     SCRP = SCRP0#'ServiceChangeResParm'{timeStamp = Val},
%     merge_ServiceChangeResParm(Parms, SCRP);

% merge_ServiceChangeResParm([{Tag, Val}|_Parms], SCRP) ->
%     Val2 = 
% 	case Tag of
% 	    address    -> SCRP#'ServiceChangeResParm'.serviceChangeAddress;
% 	    mgc_id     -> SCRP#'ServiceChangeResParm'.serviceChangeMgcId;
% 	    profile    -> SCRP#'ServiceChangeResParm'.serviceChangeProfile;
% 	    version    -> SCRP#'ServiceChangeResParm'.serviceChangeVersion;
% 	    time_stamp -> SCRP#'ServiceChangeResParm'.timeStamp
% 	end,
%     exit({at_most_once_servChgReplyParm, {Tag, Val, Val2}}).


% ensure_serviceChangeMethod({safeToken, _Line, "fl"}) ->
%     failover;
% ensure_serviceChangeMethod({safeToken, _Line, "failover"}) ->
%     failover;
% ensure_serviceChangeMethod({safeToken, _Line, "fo"}) -> 
%     forced;
% ensure_serviceChangeMethod({safeToken, _Line, "forced"}) ->
%     forced;
% ensure_serviceChangeMethod({safeToken, _Line, "gr"}) ->
%     graceful;
% ensure_serviceChangeMethod({safeToken, _Line, "graceful"}) ->
%     graceful;
% ensure_serviceChangeMethod({safeToken, _Line, "rs"}) ->
%     restart;
% ensure_serviceChangeMethod({safeToken, _Line, "restart"}) ->
%     restart;
% ensure_serviceChangeMethod({safeToken, _Line, "dc"}) ->
%     disconnected;
% ensure_serviceChangeMethod({safeToken, _Line, "disconnected"}) ->
%     disconnected;
% ensure_serviceChangeMethod({safeToken, _Line, "ho"}) ->
%     handOff;
% ensure_serviceChangeMethod({safeToken, _Line, "handoff"}) ->
%     handOff;
% ensure_serviceChangeMethod({safeToken, Line, Text}) ->
%     return_error(Line, {bad_serviceChangeMethod, Text}).


ensure_profile({_TokenTag, Line, Text}) ->
    case string:tokens(Text, [$/]) of
        [Name, Version] ->
            Version2 = ensure_version(Version),
            #'ServiceChangeProfile'{profileName = Name, version = Version2};
        _ ->
            return_error(Line, {bad_profile, Text})
    end.

ensure_version(Version) ->
    ensure_uint(Version, 0, 99).

% merge_signalRequest(SignalName, PropertyParms) ->
%     Sig = #'Signal'{signalName = SignalName},
%     SPL = [],
%     do_merge_signalRequest(Sig, PropertyParms, SPL).

% do_merge_signalRequest(Sig, [H | T], SPL) ->
%     case H of
%         {stream, StreamId} when Sig#'Signal'.streamID == asn1_NOVALUE ->
%             do_merge_signalRequest(Sig#'Signal'{streamID = StreamId}, T, SPL);
%         {signal_type, SigType} when Sig#'Signal'.sigType == asn1_NOVALUE ->
%             do_merge_signalRequest(Sig#'Signal'{sigType = SigType}, T, SPL);
%         {duration, Duration} when Sig#'Signal'.duration == asn1_NOVALUE ->
%             do_merge_signalRequest(Sig#'Signal'{duration = Duration}, T, SPL);
%         {notify_completion, NC} when Sig#'Signal'.notifyCompletion == asn1_NOVALUE ->
%             do_merge_signalRequest(Sig#'Signal'{notifyCompletion = NC}, T, SPL);
%         keepActive when Sig#'Signal'.keepActive == asn1_NOVALUE->
%             do_merge_signalRequest(Sig#'Signal'{keepActive = true}, T, SPL);
%         {other, Name, PP} ->
%             SP = #'SigParameter'{sigParameterName = Name, 
% 				 value            = PP#'PropertyParm'.value,