megaco_text_parser_prev3c.hrl

OTP是开放电信平台的简称

merge_indAudMediaDescriptor([{streamDescr, Val}|Vals], D)  
  when D#'IndAudMediaDescriptor'.streams == asn1_NOVALUE ->
%%     d("merge_indAudMediaDescriptor(streamDescr) -> entry with"
%%       "~n   Val: ~p"
%%       "~n   D:   ~p", [Val, D]),
    D2 = #'IndAudMediaDescriptor'{streams = {multiStream, [Val]}},
    merge_indAudMediaDescriptor(Vals, D2);
merge_indAudMediaDescriptor([{streamDescr, Val}|Vals], 
  #'IndAudMediaDescriptor'{streams = Streams1} = D1) ->
%%     d("merge_indAudMediaDescriptor() -> entry with"
%%       "~n   Val:      ~p"
%%       "~n   Streams1: ~p"
%%       "~n   D1:       ~p", [Val, Streams1, D1]),
    Streams2 = 
	case Streams1 of
	    {multiStream, Descs} ->
		{multiStream, [Val|Descs]};
	    _ ->
		return_error(0, {bad_IndAudMediaDescriptor_streamDescr, 
				 Val, Streams1})
	end,
    D2 = D1#'IndAudMediaDescriptor'{streams = Streams2},
    merge_indAudMediaDescriptor(Vals, D2);
merge_indAudMediaDescriptor([{Tag, Val}|_], D) ->
%%     d("merge_indAudMediaDescriptor -> entry with"
%%       "~n   Tag: ~p"
%%       "~n   Val: ~p"
%%       "~n   D:   ~p", [Tag, Val, D]),
    case Tag of
	termStateDescr ->
	    return_error(0, {bad_IndAudMediaDescriptor_termStateDescr, 
			     Val, D#'IndAudMediaDescriptor'.termStateDescr});
	streamParm ->
	    return_error(0, {bad_IndAudMediaDescriptor_streamParm, 
			     Val, D#'IndAudMediaDescriptor'.streams});
	streamDescr ->
	    return_error(0, {bad_IndAudMediaDescriptor_streamDescr, 
			     Val, D#'IndAudMediaDescriptor'.streams});
	_ ->
	    return_error(0, {bad_IndAudMediaDescriptor_tag, Tag, Val})
    end.

merge_indAudLocalControlDescriptor(Parms) ->
    merge_indAudLocalControlDescriptor(Parms, 
					  #'IndAudLocalControlDescriptor'{},
					  asn1_NOVALUE).
					  
merge_indAudLocalControlDescriptor([modeToken | Parms], D, PP) 
  when (D#'IndAudLocalControlDescriptor'.streamMode    == asn1_NOVALUE) and 
       (D#'IndAudLocalControlDescriptor'.streamModeSel == asn1_NOVALUE) ->
%%     d("merge_indAudLocalControlDescriptor(modeToken,1) -> entry when"
%%       "~n   D:  ~p"
%%       "~n   PP: ~p", [D, PP]),
    D2 = D#'IndAudLocalControlDescriptor'{streamMode = 'NULL'},
    merge_indAudLocalControlDescriptor(Parms, D2, PP);

merge_indAudLocalControlDescriptor([modeToken | Parms], D, PP) 
  when (D#'IndAudLocalControlDescriptor'.streamMode == asn1_NOVALUE) ->
%%     d("merge_indAudLocalControlDescriptor(modeToken,2) -> entry when"
%%       "~n   D:  ~p"
%%       "~n   PP: ~p", [D, PP]),
    merge_indAudLocalControlDescriptor(Parms, D, PP);

merge_indAudLocalControlDescriptor([{mode, Val} | Parms], D, PP) 
  when (D#'IndAudLocalControlDescriptor'.streamMode    == asn1_NOVALUE) and 
       (D#'IndAudLocalControlDescriptor'.streamModeSel == asn1_NOVALUE) ->
%%     d("merge_indAudLocalControlDescriptor(mode,1) -> entry when"
%%       "~n   Val: ~p"
%%       "~n   D:   ~p"
%%       "~n   PP:  ~p", [Val, D, PP]),
    D2 = 
	case Val of
	    {equal, Val2} ->
		D#'IndAudLocalControlDescriptor'{streamModeSel = Val2};
	    {inequal, Val2} ->
		D#'IndAudLocalControlDescriptor'{streamModeSel = Val2}
	end,
    merge_indAudLocalControlDescriptor(Parms, D2, PP);

merge_indAudLocalControlDescriptor([{mode, Val} | Parms], D, PP) 
  when (D#'IndAudLocalControlDescriptor'.streamModeSel == asn1_NOVALUE) ->
%%     d("merge_indAudLocalControlDescriptor(mode,2) -> entry when"
%%       "~n   Val: ~p"
%%       "~n   D:   ~p"
%%       "~n   PP:  ~p", [Val, D, PP]),
    D2 = 
	case Val of
	    {equal, Val2} ->
		D#'IndAudLocalControlDescriptor'{streamMode    = asn1_NOVALUE,
						 streamModeSel = Val2};
	    {inequal, Val2} ->
		D#'IndAudLocalControlDescriptor'{streamMode    = asn1_NOVALUE,
						 streamModeSel = Val2}
	end,
    merge_indAudLocalControlDescriptor(Parms, D2, PP);

merge_indAudLocalControlDescriptor([reservedGroupToken | Parms], D, PP) 
  when D#'IndAudLocalControlDescriptor'.reserveGroup == asn1_NOVALUE ->
%%     d("merge_indAudLocalControlDescriptor(reservedGroupToken) -> entry when"
%%       "~n   D:  ~p"
%%       "~n   PP: ~p", [D, PP]),
    D2 = D#'IndAudLocalControlDescriptor'{reserveGroup = 'NULL'},
    merge_indAudLocalControlDescriptor(Parms, D2, PP);

merge_indAudLocalControlDescriptor([reservedValueToken | Parms], D, PP) 
  when D#'IndAudLocalControlDescriptor'.reserveValue == asn1_NOVALUE ->
%%     d("merge_indAudLocalControlDescriptor(reservedValueToken) -> entry when"
%%       "~n   D:  ~p"
%%       "~n   PP: ~p", [D, PP]),
    D2 = D#'IndAudLocalControlDescriptor'{reserveValue = 'NULL'},
    merge_indAudLocalControlDescriptor(Parms, D2, PP);

%% This is really wierd in the standard, so at this point this is the
%% best I can do...  BUGBUG BUGBUG BUGBUG
%% 
merge_indAudLocalControlDescriptor([{name, Val} | Parms], D, asn1_NOVALUE) ->
%%     d("merge_indAudLocalControlDescriptor(name) -> entry when"
%%       "~n   Val: ~p"
%%       "~n   D:   ~p", [Val, D]),
    PP = #'IndAudPropertyParm'{name = Val},
    merge_indAudLocalControlDescriptor(Parms, D, PP);

merge_indAudLocalControlDescriptor([{name, Val} | Parms], D, PP) 
  when D#'IndAudLocalControlDescriptor'.propertyParms == asn1_NOVALUE ->
%%     d("merge_indAudLocalControlDescriptor(name) -> entry when"
%%       "~n   Val: ~p"
%%       "~n   D:   ~p", [Val, D]),
    D2  = D#'IndAudLocalControlDescriptor'{propertyParms = [PP]},
    PP2 = #'IndAudPropertyParm'{name = Val},
    merge_indAudLocalControlDescriptor(Parms, D2, PP2);

merge_indAudLocalControlDescriptor([{name, Val} | Parms], D, PP) ->
%%     d("merge_indAudLocalControlDescriptor(name) -> entry when"
%%       "~n   Val: ~p"
%%       "~n   D:   ~p", [Val, D]),
    PPs = D#'IndAudLocalControlDescriptor'.propertyParms,
    D2  = D#'IndAudLocalControlDescriptor'{propertyParms = [PP|PPs]},
    PP2 = #'IndAudPropertyParm'{name = Val},
    merge_indAudLocalControlDescriptor(Parms, D2, PP2);

%% BUGBUG BUGBUG I cannot construct a proper IndAudPropertyParm with
%% just the prop (the mandatory name part is missing), so for now I
%% assume that it this has been used, then the name part
%% (pkgdName) must precide it? 
merge_indAudLocalControlDescriptor([{prop, Val} | Parms], D, PP) 
  when (PP =/= asn1_NOVALUE) and 
       (D#'IndAudLocalControlDescriptor'.propertyParms == asn1_NOVALUE) ->
%%     d("merge_indAudLocalControlDescriptor(prop,1) -> entry when"
%%       "~n   Val: ~p"
%%       "~n   D:   ~p"
%%       "~n   PP:  ~p", [Val, D, PP]),
    PP2 = PP#'IndAudPropertyParm'{propertyParms = Val},
    D2  = D#'IndAudLocalControlDescriptor'{propertyParms = [PP2]},
    merge_indAudLocalControlDescriptor(Parms, D2, asn1_NOVALUE);

merge_indAudLocalControlDescriptor([{prop, Val} | Parms], D, PP) 
  when (PP =/= asn1_NOVALUE) and 
       is_list(D#'IndAudLocalControlDescriptor'.propertyParms) ->
%%     d("merge_indAudLocalControlDescriptor(prop,2) -> entry when"
%%       "~n   Val: ~p"
%%       "~n   D:   ~p"
%%       "~n   PP:  ~p", [Val, D, PP]),
    PPs = D#'IndAudLocalControlDescriptor'.propertyParms,
    PP2 = PP#'IndAudPropertyParm'{propertyParms = Val},
    D2  = D#'IndAudLocalControlDescriptor'{propertyParms = [PP2|PPs]},
    merge_indAudLocalControlDescriptor(Parms, D2, asn1_NOVALUE);

merge_indAudLocalControlDescriptor([H | _T], _D, _PP) ->
    return_error(0, {bad_indAudLocalControlDescriptor_parm, H});

merge_indAudLocalControlDescriptor([], D, asn1_NOVALUE) 
  when D#'IndAudLocalControlDescriptor'.propertyParms == asn1_NOVALUE ->
%%     d("merge_indAudLocalControlDescriptor -> entry when done with"
%%       "~n   D:  ~p", [D]),
    D;
merge_indAudLocalControlDescriptor([], D, asn1_NOVALUE) ->
%%     d("merge_indAudLocalControlDescriptor -> entry when done with"
%%       "~n   D:  ~p", [D]),
    PPs = D#'IndAudLocalControlDescriptor'.propertyParms,
    PropParms2 = lists:reverse(PPs),
    D#'IndAudLocalControlDescriptor'{propertyParms = PropParms2};
merge_indAudLocalControlDescriptor([], D, PP) 
  when D#'IndAudLocalControlDescriptor'.propertyParms == asn1_NOVALUE ->
%%     d("merge_indAudLocalControlDescriptor -> entry when done with"
%%       "~n   D:  ~p"
%%       "~n   PP: ~p", [D, PP]),
    D#'IndAudLocalControlDescriptor'{propertyParms = [PP]};
merge_indAudLocalControlDescriptor([], D, PP) ->
%%     d("merge_indAudLocalControlDescriptor -> entry when done with"
%%       "~n   D:  ~p"
%%       "~n   PP: ~p", [D, PP]),
    PPs  = D#'IndAudLocalControlDescriptor'.propertyParms,
    PPs2 = lists:reverse([PP|PPs]),
    D#'IndAudLocalControlDescriptor'{propertyParms = PPs2}.


merge_indAudTerminationStateDescriptor({name, Val}) ->
    PropParm = #'IndAudPropertyParm'{name = Val},
    #'IndAudTerminationStateDescriptor'{propertyParms = [PropParm]};
%% BUGBUG BUGBUG BUGBUG
merge_indAudTerminationStateDescriptor({prop, Val}) ->
    exit({incomplete_propertyParm_in_indAudTerminationStateDescriptor, Val});
merge_indAudTerminationStateDescriptor(serviceStatesToken) ->
    #'IndAudTerminationStateDescriptor'{serviceState = 'NULL'};
merge_indAudTerminationStateDescriptor({serviceStates, {equal, Val}}) ->
    #'IndAudTerminationStateDescriptor'{serviceStateSel = Val};
merge_indAudTerminationStateDescriptor({serviceStates, {inequal, Val}}) ->
    #'IndAudTerminationStateDescriptor'{serviceStateSel = Val};
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         = SID, 
			      sigType          = asn1_NOVALUE, 
			      duration         = asn1_NOVALUE, 
			      notifyCompletion = asn1_NOVALUE, 
			      keepActive       = asn1_NOVALUE, 
			      sigParList       = [],
			      requestID        = RID}) ->
    #'IndAudSignal'{signalName      = SignalName,
		    streamID        = SID,
		    signalRequestID = RID}.
    

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,