IP电话/视频会议

开发平台：
WINDOWS

h450types.h：源码内容
							//@DELB
/*
 * $Revision: 1.5 $
 * $Date: 1998/12/21 16:51:47 $
 */
////////////////////////////////////////////////////////////////
//           Copyright (c) 1996 Lucent Technologies           //
//                   All Rights Reserved                      //
//                                                            //
//                   THIS IS UNPUBLISHED                      //
//                   PROPRIETARY SOURCE                       //
//               CODE OF Lucent Technologies                  //
//                       AND elemedia                         //
//                                                            //
//      The copyright notice above does not evidence any      //
//     actual or intended publication of such source code     //
////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////
// File : h450types.h                                         //
//                                                            //
// This file defines the basic types specified in H.450.1     //
// and used in H.450.1, H.450.2 and H.450.3. It also defines  //
// 2 classes, H450NonStdParam and H450AliasAddress, that are  //
// temporary and will be replace by H225CSNonStdParameter     //
// and H225CSAliasAddress in a future release of the stack.   //
//                                                            //
//                                                            //
// History:                                                   //
//  01_Jul_1998 Created                                       //
//  22_Oct_1998 Added H4501Problem::SetProb() & GetProb()     //
//  8 Dec  1998 added the compare operator to H450AliasAddr   //
//                                                            //
//                                                            //
//////////////////////////////////////////////////////////////// 
#if (!defined(__H450TYPES_H__))
#define __H450TYPES_H__
// Forward declarations
class H4501Extension;
class H4501Code;
class H450Error;
class H4501Problem;
class H4501H225IE;
class H4501UserSubaddress;
class H4501PartySubaddress;
class H4501EndpointAddr;
class H450NonStdParam;
class H450AliasAddress;
struct Em_ObjectID;
struct EmCallTransferUnspecifiedParameter;
struct EmCallDiversionUnspecifiedParameter;
struct EmCode;
struct EmProblem;
struct EmH225InformationElement;
struct EmUserSpecifiedSubaddress;
struct EmPartySubaddress;
struct EmEndpointAddress;
struct EmNonStandardParameter;
struct EmAliasAddress;
struct EmExtensionSet;
//@DELE
// -  enum Entity type
// @see:
//		- H4501FacilityExt
enum H4501EntityType
{
    ENTT_INVALID = 0,
    ENTT_ENDPOINT,
    ENTT_ANY_ENTITY,
    ENTT_MAXIMUM
};
// -  enum ROS choice type
// @see:
//		- H4501ROS
enum H4501ROSType
{
    ROS_INVALID = 0,
    ROS_INVOKE,
    ROS_RETURN_RESULT,
    ROS_RETURN_ERROR,
    ROS_REJECT,
    ROS_MAXIMUM
};
// -  enum Interpretation APDU
// @see:
//		- H4501SuppService
enum H4501InterpretationAPDU
{
    IAPDU_INVALID = 0,		// invalid selection
    IAPDU_DISCARD_PDU,		// discard any unrecognized Invoke PDU
    IAPDU_CLEAR_CALL,		// clear call if any Invoke PDU is not recognized
    IAPDU_REJECT_PDU,		// reject any unrecognized Invoke PDU
    IAPDU_MAXIMUM			// used for range checking
};
// -  enum Problem type
// @see:
//		- H4501Problem
enum H4501ProblemType
{
    PROB_INVALID = 0,
	PROB_GENERAL_PROBLEM,
	PROB_INVOKE_PROBLEM,
	PROB_RETURN_RESULT_PROBLEM,
	PROB_RETURN_ERROR_PROBLEM,	
	PROB_REJECT_PROBLEM	
};
// -  enum General Problem
// @see:
//		- H4501Problem
enum H4501GeneralProblem
{
    GPROB_INVALID = -1,
	GPROB_UNRECOGNIZED_COMP = 0,	// unrecognized component
	GPROB_MISTYPED_COMP,			// mistyped component
	GPROB_BADLY_STRUCT_COMP			// badly structured component
};
// -  enum Invoke Problem
// @see:
//		- H4501Problem
enum H4501InvokeProblem
{
    IPROB_INVALID = -1,
	IPROB_DUPLICATE_INVOC = 0,		// duplicate invocation
	IPROB_UNRECOGNIZED_OP,			// unrecognized operation
	IPROB_MISTYPED_ARG,				// mistyped argument
	IPROB_RESOURCE_LIMIT,			// resource limitation
	IPROB_RELEASE_IN_PROG,			// release in progress
	IPROB_UNRECOGNIZED_ID,			// unrecognized linked ID
	IPROB_UNEXPECTED_RESP,			// linked response unexpected
	IPROB_UNEXPECTED_OP				// unexpected linked operation
};
// -  enum Return Result Problem
// @see:
//		- H4501Problem
enum H4501ReturnResultProblem
{
    RRPROB_INVALID = -1,
	RRPROB_UNRECOGNIZED_INVOC = 0,	// unrecognized invocation
	RRPROB_UNEXPECTED_RESULT,		// result response unexpected
	RRPROB_MISTYPED_RESULT			// mistyped result
};
// -  enum Return Error Problem
// @see:
//		- H4501Problem
enum H4501ReturnErrorProblem
{
    REPROB_INVALID = -1,
	REPROB_UNRECOGNIZED_INVOC = 0,		// unrecognized invocation
	REPROB_UNEXPECTED_RESPONSE,			// error response unexpected
	REPROB_UNRECOGNIZED_ERROR,			// unrecognized error
	REPROB_UNEXPECTED_ERROR,			// unexpected error
	REPROB_MISTYPED_PARAM				// mistyped parameter
};
//@DELB
// -  enum Reject Problem	- Not used
enum H4501RejectProblem
{
    RJPROB_INVALID = -1,
	RJPROB_GEN_UNRECOGNIZED_PDU = 0,		// general-unrecognizedPDU
	RJPROB_GEN_MISTYPED_PDU = 1,			// general-mistypedPDU
	RJPROB_GEN_BADLY_STRUCTURED_PDU = 2,	// general-badlyStructuredPDU
	RJPROB_INV_DUPLICATE_INVOKE = 10,		// invoke-duplicateInvocation
	RJPROB_INV_UNRECOGNIZED_OP = 11,		// invoke-unrecognizedOperation
	RJPROB_INV_MISTYPED_ARGUMENT = 12,		// invoke-mistypedArgument
	RJPROB_INV_RESOURCE_LIMITATION = 13,	// invoke-resourceLimitation
	RJPROB_INV_RELEASE_IN_PROGRESS = 14,	// invoke-releaseInProgress
	RJPROB_INV_UNRECOGNIZED_ID = 15,		// invoke-unrecognizedLinkedId
	RJPROB_INV_LINKED_RESPONSE = 16,		// invoke-linkedResponseUnexpected
	RJPROB_INV_UNEXPECTED_LINKED_OP = 17,	// invoke-unexpectedLinkedOperation
	RJPROB_RES_UNRECOGNIZED_INVOKE = 20,	// returnResult-unrecognizedInvocation
	RJPROB_RES_RESPONSE_UNEXPECTED = 21,	// returnResult-resultResponseUnexpected
	RJPROB_RES_MISTYPED_RESULT = 22,		// returnResult-mistypedResult
	RJPROB_ERR_UNRECOGNIZED_INVOKE = 30,	// returnError-unrecognizedInvocation
	RJPROB_ERR_RESPONSE_UNEXPECTED = 31,	// returnError-errorResponseUnexpected
	RJPROB_ERR_UNRECOGNIZED_ERROR = 32,		// returnError-unrecognizedError
	RJPROB_ERR_UNEXPECTED_ERROR = 33,		// returnError-unexpectedError
	RJPROB_ERR_MISTYPED_PARAMETER = 34		// returnError-mistypedParameter
};
//@DELE
// -  enum Code type 
// @see:
//		- H4501Code
enum H4501CodeType
{
    CDT_INVALID = 0,
	CDT_LOCAL_CODE,
	CDT_GLOBAL_CODE,
    CDT_MAXIMUM
};
//@DELB
// -  enum
enum H4501ScreeningIndicator
{
    SI_INVALID = -1,
	SI_USER_NOT_SCREENED = 0,		// user provided not screened
	SI_USER_VERIFIED_PASSED,		// user provided verified and passed
	SI_USER_VERIFIED_FAILED,		// user provided verified and failed
	SI_NETWORK						// networked provided
};
//@DELE
// -  enum	Error Parameter type
// @see:
//		- H450Error
enum H450ErrorParamType
{
	ERRPT_INVALID = 0,
	ERRPT_CT_UNSPECIFIED,		// the call transfer unspecified error parameter
	ERRPT_CD_UNSPECIFIED,		// the call diversion unspecified error parameter
    ERRPT_MAXIMUM
};
// -  enum	Error type
// @see:
//		- H450Error
enum H450ErrorType
{
	ERRT_INVALID = 0,
	ERRT_UNPARAMETERIZED,		// all H450-x errors except unspecified error
	ERRT_PARAMETERIZED,			// H450-2/H450-3 unspecified error 
    ERRT_MAXIMUM
};
// -  enum Unspecified Parameter choice
// @see:
//		- H4502UnspecifiedParam H4503UnspecifiedParam
enum H450UnspecParamType
{
	UNPT_INVALID = 0,
	UNPT_EXTENSION = 1,				// the choice is extension
	UNPT_NON_STANDARD_DATA = 2,		// the choice is nonStandard
    UNPT_MAXIMUM
};
// -  enum	Error code list 
// @see:
//		- H450Error H4501ReturnError
enum H450ErrorList
{
	// These are from table 8/H.450.1
		//@GRPB
    ERR_USER_NOT_SUBSCRIBED = 0,	// userNotSubscribed
	ERR_REJECTED_BY_NETWORK = 1,	// rejectedByNetwork
	ERR_REJECTED_BY_USER = 2,		// rejectedByUser
	ERR_NOT_AVAILABLE = 3,			// notAvailable
	ERR_INSUFFICIENT_INFO = 5,		// insufficientInformation
	ERR_INVALID_USER_NUMBER = 6,	// invalidServedUserNumber
	ERR_INVALID_CALL_STATE = 7,		// invalidCallState
	ERR_SERVICE_NOT_PROVIDED = 8,	// basicServiceNotProvided
	ERR_NOT_INCOMING_CALL = 9,		// notIncomingCall
	ERR_SUPP_SERV_NOT_ALLOWED = 10,	// supplementaryServiceInteractionNotAllowed
	ERR_RESOURCE_UNAVAILABLE = 11,	// resourceUnavailable
	ERR_CALL_FAILURE = 25,			// callFailure
	ERR_PROCEDURAL_ERROR = 43,		// proceduralError
		//@GRPE
	// These are from H.450.2
		//@GRPB
	ERR_INVALID_REROUTING_NUMBER = 1004,	// invalidReroutingNumber
	ERR_UNRECOGNIZED_CALL_ID = 1005,		// unrecognizedCallIdentity
	ERR_ESTABLISHMENT_FAILURE = 1006,		// establishmentFailure
		//@GRPE
	// These are from H.450.3
		//@GRPB
	ERR_INVALID_DIVERTED_NUMBER = 12,		// invalidDivertedNumber
	ERR_SPECIAL_SERVICE_NUMBER = 14,		// specialServiceNumber
	ERR_DIVERSION_TO_SERVED_USER = 15,		// diversionToServedUserNumber
	ERR_NUMBER_OF_DIVERSIONS_EX = 24,		// numberOfDiversionsExceeded
	ERR_TEMPORARILY_UNAVAILABLE = 1000,		// temporarilyUnavailable
	ERR_NOT_AUTHORIZED = 1007,				// notAuthorized
		//@GRPE
	// Both H.450.2 and H.450.3
		//@GRPB
	ERR_CT_UNSPECIFIED = 1008,					// unspecified
	ERR_CD_UNSPECIFIED = 1008					// unspecified
		//@GRPE
};
// -  enum Party Sub Address type 
// @see:
//		- H4501PartySubaddress
enum H4501PartySubAddrType
{
    PSAT_INVALID = 0,
    PSAT_USER_SPECIFIED,	// user specified subaddress
    PSAT_NSAP_ADDRESS		// NSAP subaddress
};
/* 
 *  This class is for the Manfacturer specific extensions.
 *  This is used in the ItemExt class as well as the H450Error class.
 *
 * @See:
 *		- used in ItemExt H4502DummyRes H4502CTIdentifyRes H4502DummyArg
 *		H4502CTInitiateArg H4502CTSetupArg H4502CTUpdateArg
 *		H4502CTSubaddressArg H4502CTCompleteArg H4502CTActiveArg
 */
class DLLEXPORT H4501Extension
{
    public:
			// Constructor
        H4501Extension();
		H4501Extension(H4501Extension &);
			// Destructor
        ~H4501Extension();
			// This sets the extensionId
		ProtReturnCode SetObjectID(unsigned long *, int);
			// This gets the extensionId
		ProtReturnCode GetObjectID(unsigned long *&, int &);
			// This sets the extensionArgument
		ProtReturnCode SetArgument(unsigned char *, int);
			// This gets the extensionArgument
		ProtReturnCode GetArgument(unsigned char *&, int &);
        H4501Extension & operator=(H4501Extension &);
			// Determines if the class has been sufficiently created
        boolean Valid();
		//@DELB
        // For protocol internal use.
        EmExtensionSet *GetPriv();
        ProtReturnCode SetPriv(EmExtensionSet *);
    private:
		void Init();
		EmExtensionSet *mExtPtr;
		Em_ObjectID *mObjIdPtr;
        int mIdSet;
        int mArgSet;
        int mIsValid;
		//@DELE
};
/*
 *  This is the class for the CODE field. 
 *  All of the currently defined CODE objects in H.450
 *  are set to the local code type. However, methods
 *  are provided in this class to deal with global
 *  code types as well.
 *
 * The GetLocalCode(), and GetGlobalCode() 
 * methods will return a H450_INCONSISTENT_TYPES 
 * error if used on the wrong code type.
 * @Caveats:
 * For incoming code objects, use the GetType() 
 * method first, then the approprite Get method.
 *
 * @See:
 *		- used in H4501Invoke H4501ReturnResult
 *		H4501ReturnError H450Error
 */
class DLLEXPORT H4501Code
{
    public:
			// Constructor
		H4501Code();
		H4501Code(H4501Code &);
			// Destructor
		~H4501Code();
			// This gets the code type.
			//
			// A SetType method is not provided because 
			// both the SetLocalCode() and SetGlobalCode() 
			// methods below set the code type prior to 
			// setting the specific code.
			// @See:
			//		- enum H4501CodeType
		int GetType();
			// This sets the local code field.
			//
			//<PRE>
			// For Operation type code used in H4501Invoke and
			// H4501ReturnResult see
			//		- enum H4502CTOperationType
			//		- enum H4503CDOperationType
			//
			// For ReturnError errorcode used in H4501ReturnError see
			//		- class H450Error
			//		- enum H450ErrorList
			//</PRE>
		ProtReturnCode SetLocalCode(int);
			// This gets the local code field.
			//
			//<PRE>
			// For Operation type code used in H4501Invoke and
			// H4501ReturnResult see
			//		- enum H4502CTOperationType
			//		- enum H4503CDOperationType
			//
			// For ReturnError errorcode used in H4501ReturnError see
			//		- class H450Error
			//		- enum H450ErrorList
			//</PRE>
		ProtReturnCode GetLocalCode(int &);
			// This sets the global code field.
		ProtReturnCode GetGlobalCode(unsigned long *&, int &);
			// This gets the global code field.
		ProtReturnCode SetGlobalCode(unsigned long *, int);
        H4501Code & operator=(H4501Code &);
		// Determines if the class has been sufficiently created
        boolean Valid();
		//@DELB
        // For protocol internal use.
        EmCode *GetPriv();
        ProtReturnCode SetPriv(EmCode *);
		void SetValid();
	private:
		void Init();
		EmCode *mCodePtr;
		int mIsValid;
		//@DELE
};
/*
 *  This is the abstract base class for all ERROR PARAMETER  fields.
 *  The unspecified error is currently defined defined in H.450.2.
 *
 * @See:
 *		- used in H4502UnspecifiedParam H4503UnspecifiedParam H450Error
 */
class DLLEXPORT H450ErrorParameter
{
    public:
			// Constructor
		H450ErrorParameter(int);
			// Constructor
		virtual ~H450ErrorParameter();
			// This gets the error parameter type.
			// Currently only one error parameter type is 
			// defined: the unspecified error
			// @See:
			//		- enum H450ErrorParamType 
		int GetParamType();
			// This factory method creates the appropriate error
			// parameter of the specified type.
		static ProtReturnCode Factory(H450ErrorParameter *&, int type);
			// Determines if the class has been sufficiently created
		virtual boolean Valid() = 0;
		//@DELB
        // For protocol internal use.
        virtual void *GetPriv() = 0;
        virtual ProtReturnCode SetPriv(void *) = 0;
	private:
		int mType;
		//@DELE
};
/*
 *  This is for the PARAMETER field of the H.450.2
 *  call transfer unspecified error.
 *
 * The GetExtension() and GetNonStdData() methods will
 * return a H450_INCONSISTENT_TYPES error if used on the 
 * wrong parameter type
 * @Caveats:
 * For incoming parameter objects, use the GetParamType()
 * method first, then the approprite Get method.
 *
 * @See:
 *		- used in H450ErrorParameter
 */
class DLLEXPORT H4502UnspecifiedParam : public H450ErrorParameter
{
    public:
			// Constructor
		H4502UnspecifiedParam();
		H4502UnspecifiedParam(H4502UnspecifiedParam &);
			// Destructor
		~H4502UnspecifiedParam();
			// This gets the choice type.
			//
			// A SetParamType method is not provided because 
			// the SetExtension() and the SetNonStdData() methods 
			// below set the parameter choice prior to setting 
			// the specific parameter.
			// @See:
			//		- enum H450UnspecParamType
		int GetType();
			// This sets the extension field.
		ProtReturnCode SetExtension(H4501Extension &);
			// This gets the extension field.
		ProtReturnCode GetExtension(H4501Extension &);
			// This sets the nonStandard field.
		ProtReturnCode SetNonStdData(H450NonStdParam &);
			// This gets the nonStandard field.
		ProtReturnCode GetNonStdData(H450NonStdParam &);
        H4502UnspecifiedParam & operator=(H4502UnspecifiedParam &);
			// Determines if the class has been sufficiently created
        boolean Valid();
		//@DELB
        // For protocol internal use.
        void *GetPriv();
        ProtReturnCode SetPriv(void *);
	private:
		void Init();
		EmCallTransferUnspecifiedParameter *mUnPtr;
		int mIsValid;
		//@DELE
};
/*
 *  This is for the PARAMETER field of the H.450.3
 *  call diversion unspecified error.
 *
 * The GetExtension() and GetNonStdData() methods will
 * return a H450_INCONSISTENT_TYPES error if used on the 
 * wrong parameter type
 * @Caveats:
 * For incoming parameter objects, use the GetParamType()
 * method first, then the approprite Get method.
 *
 * @See:
 *		- used in H450ErrorParameter
 */
class DLLEXPORT H4503UnspecifiedParam : public H450ErrorParameter
{
    public:
			// Constructor
		H4503UnspecifiedParam();
		H4503UnspecifiedParam(H4503UnspecifiedParam &);
			// Destructor
		~H4503UnspecifiedParam();
			// This gets the choice type.
			//
			// A SetParamType method is not provided because 
			// the SetExtension() and the SetNonStdData() methods 
			// below set the parameter choice prior to setting 
			// the specific parameter.
			// @See:
			//		- enum H450UnspecParamType
		int GetType();
			// This sets the extension field.
		ProtReturnCode SetExtension(H4501Extension &);
			// This gets the extension field.
		ProtReturnCode GetExtension(H4501Extension &);
			// This sets the nonStandard field.
		ProtReturnCode SetNonStdData(H450NonStdParam &);
			// This gets the nonStandard field.
		ProtReturnCode GetNonStdData(H450NonStdParam &);
        H4503UnspecifiedParam & operator=(H4503UnspecifiedParam &);
			// Determines if the class has been sufficiently created
        boolean Valid();
		//@DELB
        // For protocol internal use.
        void *GetPriv();
        ProtReturnCode SetPriv(void *);
	private:
		void Init();
		EmCallDiversionUnspecifiedParameter *mUnPtr;
		int mIsValid;
		//@DELE
};
/*
 *  This is for all of the errors defined in H.450.1, H.450.2
 *  and H.450.3
 *
 * For incoming error objects, use the GetType()
 * method first. If it is not an unspecified
 * error, then use the GetH450Error() method to
 * retrieve the actual error number. If it is
 * an unspecified error, then use the GetParameter()
 * method to retrieve the PARAMETER field.
 *
 * For outgoing error object, use the SetH450Error()
 * alone to set all errors except the unspecified 
 * error. For the unspecified error, use the 
 * SetH450Error(ERR_CT_UNSPECIFIED) or SetH450Error(ERR_CD_UNSPECIFIED)
 * method followed by the SetParameter() method.
 *
 * For all values except ERR_CT_UNSPECIFIED, and ERR_CD_UNSPECIFIED
 * SetH450Error() sets the error type to 
 * ERRT_UNPARAMETERIZED, and for ERR_*_UNSPECIFIED values, 
 * SetH450Error() sets the type to ERRT_PARAMETERIZED. 
 * In all cases, SetH450Error() sets the CODE 
 * choice to local. 
 *
 * @See:
 *		- used in H4501ReturnError
 */
class DLLEXPORT H450Error
{
    public:
			// Constructor
		H450Error();
		H450Error(H450Error &);
			// Constructor
		~H450Error();
			// This gets the error type.
			// @See:
			//		- enum H450ErrorType
		int GetType();
			// This sets all but one H.450 error contain only CODE values.
			// This method sets the code, and sets the choice to local
			// @See:
			//		- enum H450ErrorList
		ProtReturnCode SetH450Error(int);
			// This gets the error CODE value.
		ProtReturnCode GetH450Error(int &);
			// This sets errors that contain PARAMETER fields.
			// (Currently, only one is define: unspecified error)
		ProtReturnCode SetParameter(H450ErrorParameter &);
			// This gets error PARAMETER type.
			// (Currently, only one is define: unspecified error)
			// @See:
			//		- enum H450ErrorParamType
		ProtReturnCode GetParameterType(int &);
			// This gets the error PARAMETER field.
			// @Caveats:
			//   Use GetParameterType first to determine the parameter type
		ProtReturnCode GetParameter(H450ErrorParameter &);
			// This sets the CODE field.
			// This method is general purpose by nature and is not
			// necessary since all H.450 errors use the local choice of
			// CODE. This is provided only for the sake of completeness.
		ProtReturnCode SetCode(H4501Code &);
			// This gets the CODE field.
			// This method is general purpose by nature and is not
			// necessary since all H.450 errors use the local choice of
			// CODE. This is provided only for the sake of completeness.
		ProtReturnCode GetCode(H4501Code &);
        H450Error & operator=(H450Error &);
			// Determines if the class has been sufficiently created
        boolean Valid();
		//@DELB
        // For protocol internal use.
        EmCode *GetCodePriv();
        ProtReturnCode SetCodePriv(EmCode *);
        EmCallTransferUnspecifiedParameter *GetCTUnspecifiedPriv();
        ProtReturnCode SetCTUnspecifiedPriv(EmCallTransferUnspecifiedParameter *);
        EmCallDiversionUnspecifiedParameter *GetCDUnspecifiedPriv();
        ProtReturnCode SetCDUnspecifiedPriv(EmCallDiversionUnspecifiedParameter *);
	private:
		void Init();
		EmCode *mCodePtr;
		void *mUnPtr;
		int mIsValid;
		int mCodeSet;
		int mParamSet;
		int mParamType;
		int mType;
		//@DELE
};
/*  
 *  This defines the problem choice used in the Reject ROS.
 *
 * All of the respective Get methods will return a 
 * H450_INCONSISTENT_TYPES error if used on the wrong 
 * problem type.
 * @Caveats:
 * For incoming problem objects, use the GetType() method
 * first, then the approprite Get method.
 *
 * @See:
 *		- used in H4501Reject
 */
class DLLEXPORT H4501Problem
{
    public:
			// Constructor
		H4501Problem();
		H4501Problem(H4501Problem &);
			// Constructor
		~H4501Problem();
			// This sets any of the 4 problem types.
			// @See:
			//		- enum H4501GeneralProblem
			//		- enum H4501InvokeProblem
			//		- enum H4501ReturnResultProblem
			//		- enum H4501ReturnErrorProblem
		ProtReturnCode SetProb(int type, int prob);
			// This gets any of the 4 problem types.
			// Use GetType() to get the problem type
		ProtReturnCode GetProb(int &type, int &prob);
			// This gets the problem type.
			//
			// A SetType() method is not provided because the 
			// SetProb() sets the type.  Also SetGeneralProb(),
			// SetInvokeProb(), SetResultProb() and the
			// SetErrorProb() methods all set the problem
			// type prior to setting the specific problem. 
			// @See:
			//		- enum H4501ProblemType
		int GetType();
			// This is a convenience method to set general problems.
			// @See:
			//		- enum H4501GeneralProblem
		ProtReturnCode SetGeneralProb(int);
			// This is a convenience method to get general problems.
		ProtReturnCode GetGeneralProb(int &);
			// This is a convenience method to set invoke problems.
			// @See:
			//		- enum H4501InvokeProblem
		ProtReturnCode SetInvokeProb(int);
			// This is a convenience method to get invoke problems.
		ProtReturnCode GetInvokeProb(int &);
			// This is a convenience method to set return result problems.
			// @See:
			//		- enum H4501ReturnResultProblem
		ProtReturnCode SetResultProb(int);
			// This is a convenience method to get return result problems.
		ProtReturnCode GetResultProb(int &);
			// This is a convenience method to set return error problems.
			// @See:
			//		- enum H4501ReturnErrorProblem
		ProtReturnCode SetErrorProb(int);
			// This is a convenience method to get return error problems.
		ProtReturnCode GetErrorProb(int &);
        H4501Problem & operator=(H4501Problem &);
			// Determines if the class has been sufficiently created
        boolean Valid();
		//@DELB
        // For protocol internal use.
        EmProblem *GetPriv();
        ProtReturnCode SetPriv(EmProblem *);
		void SetValid();
	private:
		void Init();
		EmProblem *mProbPtr;
		int mIsValid;
		//@DELE
};
/*  
 *  This defines the H225InformationElement 
 *
 * @See:
 *		- used in ItemElements H4502CTUpdateArg 
 *			H4502CTCompleteArg H4502CTActiveArg
 */
class DLLEXPORT H4501H225IE
{
    public:
			// Constructor
        H4501H225IE();
		H4501H225IE(H4501H225IE &);
			// Constructor
        ~H4501H225IE();
			// This sets raw information elements.
			// see H.225 Q931IE::GetRaw for details
        ProtReturnCode SetH225IE(unsigned char *, int len);
			// This gets raw information elements.
			// see H.225 Q931IE::GetRaw for details
        ProtReturnCode GetH225IE(unsigned char *&, int &len);
			// This sets specific elemedia PX3230S stack 
			// defined information elements.
        ProtReturnCode SetH225IE(Q931IE &);
			// This gets specific elemedia PX3230S stack 
			// defined information elements.
        ProtReturnCode GetH225IE(Q931IE &);
        H4501H225IE & operator=(H4501H225IE &);
			// Determines if the class has been sufficiently created
        boolean Valid();
		//@DELB
        // For protocol internal use.
        EmH225InformationElement *GetPriv();
        ProtReturnCode SetPriv(EmH225InformationElement *);
    private:
		void Init();
        EmH225InformationElement *mInfoElemPtr;
        int mIsValid;
		//@DELE
};
/*  
 *  This defines the UserSpecifiedSubaddress sequence.
 *  It is used in the H.450.2 PartySubaddress choice.
 *
 * @See:
 *		- used in H4501PartySubaddress
 */
class DLLEXPORT H4501UserSubaddress
{
    public:
			// Constructor
        H4501UserSubaddress();
		H4501UserSubaddress(H4501UserSubaddress &);
			// Destructor
        ~H4501UserSubaddress();
			// Mandatory - This sets the subaddressInformation field
			// It is an octet string with a maximum length of 20.
        ProtReturnCode SetSubaddrInfo(unsigned char *, int len);
			// Mandatory - This gets the subaddressInformation field
			// It is an octet string with a maximum length of 20.
        ProtReturnCode GetSubaddrInfo(unsigned char *&, int &len);
			// Optional - This sets the oddCountIndicator field.
			// It is used when the coding of the subaddress is BCD.
			//
			// The constructor sets this field to not-included as a default.
		ProtReturnCode SetIndicator(boolean);
			// Optional - This gets the oddCountIndicator field.
		ProtReturnCode GetIndicator(boolean &);
        H4501UserSubaddress & operator=(H4501UserSubaddress &);
			// Determines if the class has been sufficiently created
        boolean Valid();
		//@DELB
        // For protocol internal use.
        EmUserSpecifiedSubaddress *GetPriv();
        ProtReturnCode SetPriv(EmUserSpecifiedSubaddress *);
    private:
		void Init();
        EmUserSpecifiedSubaddress *mSubPtr;
        int mIsValid;
		//@DELE
};
/*  
 *  This defines the PartySubaddress ASN.1 choice.
 *  This is used in the H.450.2 SubaddressTransferArg and throughout
 *  H.450.3 Call Diversion Operations.
 *
 * All of the respective Get methods will 
 * return a H450_INCONSISTENT_TYPES error if used on 
 * the wrong subaddress type.
 * @Caveats:
 * For incoming subaddress objects, use the GetType() method first,
 * then the approprite Get method.
 *
 * @See:
 *		- used in H4502CTSubaddressArg
 */
class DLLEXPORT H4501PartySubaddress
{
    public:
			// Constructor
        H4501PartySubaddress();
		H4501PartySubaddress(H4501PartySubaddress &);
			// Destructor
        ~H4501PartySubaddress();
			// This gets the party sub address type.
			//
			// A SetType method is not provided because the both 
			// the SetUserSpecified() and the SetNSAP() methods 
			// set the choice prior to setting the specific subaddress.
			// @See:
			//		- enum H4501PartySubAddrType
		int GetType();
			// This sets the userSpecifiedSubaddress field 
			// which is UserSpecifiedSubaddress sequence.
        ProtReturnCode SetUserSpecified(H4501UserSubaddress &);
			// This gets the userSpecifiedSubaddress field 
			// which is UserSpecifiedSubaddress sequence.
        ProtReturnCode GetUserSpecified(H4501UserSubaddress &);
			// This sets the nsapSubaddress field.
			// It is a NSAPSubaddress octet string specified according to 
			// X.213 with a maximum length of 20.
        ProtReturnCode SetNSAP(unsigned char *, int len);
			// This gets the nsapSubaddress field.
        ProtReturnCode GetNSAP(unsigned char *&, int &len);
        H4501PartySubaddress & operator=(H4501PartySubaddress &);
			// Determines if the class has been sufficiently created
        boolean Valid();
		//@DELB
        // For protocol internal use.
        EmPartySubaddress *GetPriv();
        ProtReturnCode SetPriv(EmPartySubaddress *);
    private:
		void Init();
        EmPartySubaddress *mPartyPtr;
        int mIsValid;
		//@DELE
};
/*  
 *  This defines the EndpointAddress ASN.1 sequence.
 *  This is used in the H4502CTIdentifyRes, H4502CTInitiateArg,
 *  H4502CTSetupArg, H4502CTUpdateArg, H4502CTCompleteArg,
 *  H4502CTActiveArg H.450.2 classes as well as various H.450.3 Call
 *  Diversion Operations.
 *
 *  Note that the name of the AliasAddress used in this class will 
 *  change to H225CSAliasAddress in a future release of the stack.
 *
 * @See:
 *		- used in ItemNumber H4502CTIdentifyRes H4502CTInitiateArg
 *			H4502CTSetupArg H4502CTUpdateArg H4502CTCompleteArg 
 *			H4502CTActiveArg
 */
class DLLEXPORT H4501EndpointAddr
{
    public:
			// Constructor
        H4501EndpointAddr();
		H4501EndpointAddr(H4501EndpointAddr &);
			// Destructor
        ~H4501EndpointAddr();
			// Mandatory - This sets the destinationAddress field. 
		ProtReturnCode AddDestAddr(H450AliasAddress &);
			// Mandatory - This gets the number of destinationAddresses
		ProtReturnCode GetNumDestAddrs(int &count);
			// Mandatory - This gets the list of destinationAddresses
			// @Caveats:
			// Use GetNumDestAddrs() first
		ProtReturnCode GetDestAddrs(H450AliasAddress list[], int &count);
			// Optional - This sets the remoteExtensionAddress field.
        ProtReturnCode SetRemoteExtAddr(H450AliasAddress &);
			// Optional - This gets the remoteExtensionAddress field.
        ProtReturnCode GetRemoteExtAddr(H450AliasAddress &);
        H4501EndpointAddr & operator=(H4501EndpointAddr &);
			// Determines if the class has been sufficiently created
        boolean Valid();
		//@DELB
        // For protocol internal use.
        EmEndpointAddress *GetPriv();
        ProtReturnCode SetPriv(EmEndpointAddress *);
		void SetValid();
    private:
		void Init();
        EmEndpointAddress *mAddrPtr;
        int mIsValid;
		//@DELE
};
/**
  *  NOTE:
  *
  *  The remaining class definitions are only temporary and
  *  will be replaced by their H.225.0 counterpart in a future
  *  release of the stack.
 **/
/*  
 *  This defines the NonStandardParameter ASN.1 sequence.
 *
 *  Note that the name of this class, H450NonStdParam, will 
 *  change to H225CSNonStdParameter in a future release of 
 *  the stack.
 *
 * @See:
 *		- used in ItemExt H4502UnspecifiedParam
 */
class DLLEXPORT H450NonStdParam
{
    public:
			// Constructor
        H450NonStdParam();
		H450NonStdParam(H450NonStdParam &);
			// Destructor
        ~H450NonStdParam();
			// This gets the type received
			// @See:
			//		- enum H225CSNonStdIDType
		int GetIDType();
			// This sets the H221NonStd choice.
        ProtReturnCode SetH221NonStd(unsigned short t35_cc, 
        		unsigned short t35_ext, unsigned short m_code);
			// This gets the H221NonStd choice.
        ProtReturnCode GetH221NonStd(unsigned short &t35_cc, 
        		unsigned short &t35_ext, unsigned short &m_code);
			// This sets the ObjectIdentifier choice.
        ProtReturnCode SetObjectIdentifier(unsigned long *data, int len);
			// This gets the ObjectIdentifier choice.
        ProtReturnCode GetObjectIdentifier(unsigned long *&data, int &len);
			// Mandatory - This sets the nonStandardData field
        ProtReturnCode SetNonStdData(unsigned char *data, int len);
			// Mandatory - This gets the nonStandardData field
        ProtReturnCode GetNonStdData(unsigned char *&data, int &len);
        H450NonStdParam & operator=(H450NonStdParam &);
			// Determines if the class has been sufficiently created
        boolean Valid();
		//@DELB
        // For protocol internal use.
        EmNonStandardParameter *GetPriv();
        ProtReturnCode SetPriv(EmNonStandardParameter *);
		void SetValid();
    private:
		void Init();
        EmNonStandardParameter *mParamPtr;
        int mIsValid;
		int mDataSet;
		int mIdSet;
		//@DELE
};
/*  
 *  This defines the AliasAddress ASN.1 choice.
 *
 *  Note that the name of this class, H450AliasAddress, will 
 *  change to H225CSAliasAddress in a future release of the stack.
 *
 * All of the respective Get methods will return an
 * H450_INCONSISTENT_TYPES error if used on the wrong address
 * type.
 * @Caveats:
 * For incoming alias address objects, use the GetType() method 
 * first, then the approprite Get method.
 *
 * @See:
 *		- used in H4501FacilityExt H4501EndpointAddr
 */
class DLLEXPORT H450AliasAddress
{
    public:
			// Constructor
        H450AliasAddress();
		H450AliasAddress(H450AliasAddress &);
			// Destructor
        ~H450AliasAddress();
			// This gets the type received
			//
			// A SetType method is not provided because the SetH323ID(),
			// SetE164(), SetURLID(), SetEMailID(), SetTransportID and 
			// SetPartyNumber() methods below set the choice prior to 
			// setting the specific alias address.
			// @Set:
			//		- H225CSAliasAddressType
		int GetType();
			// This sets the e164 field.
			// It is a IA5String with a maximum length of 128.
        ProtReturnCode SetE164(char *, int len);
			// This gets the e164 field.
        ProtReturnCode GetE164(char *&, int &len);
			// This sets the h323-ID field.
			// It is a BMPString with a maximum length of 256.
        ProtReturnCode SetH323ID(unsigned short *, int len);
			// This gets the h323-ID field.
        ProtReturnCode GetH323ID(unsigned short *&, int &len);
			// This sets the url-ID field.
			// It is a IA5String with a maximum length of 512.
        ProtReturnCode SetURLID(char *, int len);
			// This gets the url-ID field.
        ProtReturnCode GetURLID(char *&, int &len);
			// This sets the transportID field.
			// It is a TransportAddress.
        ProtReturnCode SetTransportID(sockaddr *);
			// This gets the transportID field.
        ProtReturnCode GetTransportID(sockaddr *);
			// This sets the email-ID field.
			// It is a IA5String with a maximum length of 512.
        ProtReturnCode SetEMailID(char *, int len);
			// This gets the email-ID field.
        ProtReturnCode GetEMailID(char *&, int &len);
        H450AliasAddress & operator=(H450AliasAddress &);
        boolean operator==(H450AliasAddress &);
			// Determines if the class has been sufficiently created
        boolean Valid();
		//@DELB
        // For protocol internal use.
        EmAliasAddress *GetPriv();
        ProtReturnCode SetPriv(EmAliasAddress *);
		void SetValid();
    private:
		void Init();
        EmAliasAddress *mAliasPtr;
        int mIsValid;
		//@DELE
};
//@DELB
#endif	//  __H450TYPES_H__
//@DELE

						