
/*
 * This file was generated by the SOM Compiler.
 * FileName: eventcom.xh.
 * Generated using:
 *     SOM Precompiler somipc: 2.29.1.19
 *     SOM Emitter emitxh.dll: 2.108
 */

#ifndef SOM_Module_eventcom_EventComm_defined
#define SOM_Module_eventcom_EventComm_defined 1
#include <som.xh>

/*
 * Start of bindings for IDL types
 */

class SOMClass;
class SOMObject;
#define ex_EventComm_Disconnected "::EventComm::Disconnected"
typedef
struct EventComm_Disconnected {
long  ErrCode;
char  Reason[80];
} EventComm_Disconnected;

#ifndef SOM_DONT_USE_SHORT_NAMES
#ifndef SOMTGD_ex_Disconnected
    #ifdef ex_Disconnected
        #undef ex_Disconnected
        #define SOMTGD_ex_Disconnected 1
    #else
        #define ex_Disconnected ex_EventComm_Disconnected
    #endif /* ex_Disconnected */
#endif /* SOMTGD_ex_Disconnected */
#ifndef SOMTGD_Disconnected
    #ifdef Disconnected
        #undef Disconnected
        #define SOMTGD_Disconnected 1
    #else
        #define Disconnected EventComm_Disconnected
    #endif /* Disconnected */
#endif /* SOMTGD_Disconnected */
#endif /* SOM_DONT_USE_SHORT_NAMES */

/*
 * End of bindings for IDL types.
 */
#endif /* SOM_Module_eventcom_EventComm_defined */

#ifndef SOM_EventComm_EventConnection_xh
#define SOM_EventComm_EventConnection_xh


#define EventComm_EventConnection_MajorVersion 1
#define EventComm_EventConnection_MinorVersion 1
class EventComm_EventConnection;

/* Parents */
#ifndef SOM_SOMObject_xh
#ifdef SOMLOCALINCLUDES
#include "somobj.xh"
#else
#include <somobj.xh>
#endif
#endif

/* Useful C++ SOM defs */
#include <somcls.xh>
#include <somcm.xh>

#ifndef EventComm_EventConnection_API
#define EventComm_EventConnection_API
/*
 * -- The Class API
 */
#ifndef SOM_IMPORTEXPORT_event_eventcom
#ifdef SOM_DLL_event
	/* export semantics */
	#if defined(SOM_DEFFILE_event)\
	||(defined(SOM_DEFFILE_BY_DEFAULT)&&!defined(SOM_NODEFFILE_event))\
	|| !defined(SOM_Module_eventcom_Source)
	#define SOM_IMPORTEXPORT_event_eventcom
	#else
	#define SOM_IMPORTEXPORT_event_eventcom SOMDLLEXPORT
	#endif
#else
	#define SOM_IMPORTEXPORT_event_eventcom SOMDLLIMPORT
#endif
#endif

/*
 * Start of bindings for IDL types
 */


/*
 * End of bindings for IDL types.
 */

/*
 * A function to create the EventComm_EventConnection class object...
 */
SOMEXTERN SOM_IMPORTEXPORT_event_eventcom SOMClass * SOMLINK EventComm_EventConnectionNewClass(
		integer4 majorVersion,
		integer4 minorVersion);


/*
 * The API 2 ClassData Structures...
 */
SOMEXTERN struct EventComm_EventConnectionClassDataStructure {
	SOMClass *classObject;
	somMToken disconnect;
} SOMDLINK SOM_IMPORTEXPORT_event_eventcom EventComm_EventConnectionClassData;
SOMEXTERN struct EventComm_EventConnectionCClassDataStructure {
	som3ClassDetailsPtr    parentMtab;
	somDToken              instanceDataToken;
} SOMDLINK SOM_IMPORTEXPORT_event_eventcom EventComm_EventConnectionCClassData;


/*
 * Class Object and Method Token Macros
 */
#define _SOMCLASS_EventComm_EventConnection (EventComm_EventConnectionClassData.classObject)
#ifndef SOMGD_EventComm_EventConnection
    #if (defined(_EventComm_EventConnection) || defined(__EventComm_EventConnection))
        #undef _EventComm_EventConnection
        #undef __EventComm_EventConnection
        #define SOMGD_EventComm_EventConnection 1
    #else
        #define _EventComm_EventConnection _SOMCLASS_EventComm_EventConnection
    #endif /* _EventComm_EventConnection */
#endif /* SOMGD_EventComm_EventConnection */
#define EventComm_EventConnection_classObj _SOMCLASS_EventComm_EventConnection
#define _SOMMTOKEN_EventComm_EventConnection(method) ((somMToken)EventComm_EventConnectionClassData.method)

/*
 * -- Typedefs for EventComm_EventConnection Method Procedures
 */
SOMEXTERN {
typedef void   SOMLINK somTP_EventComm_EventConnection_disconnect(EventComm_EventConnection *somSelf, Environment *ev);
typedef somTP_EventComm_EventConnection_disconnect *somTD_EventComm_EventConnection_disconnect;

/*
 * -- Typedefs for Reintroduced Wrapper Methods
 */
typedef void   SOMLINK somTP_EventComm_EventConnection_somDefaultInit(EventComm_EventConnection *somSelf, 
		som3InitCtrl* ctrl);
typedef somTP_EventComm_EventConnection_somDefaultInit *somTD_EventComm_EventConnection_somDefaultInit;
typedef void   SOMLINK somTP_EventComm_EventConnection_somDestruct(EventComm_EventConnection *somSelf, 
		octet doFree, 
		som3DestructCtrl* ctrl);
typedef somTP_EventComm_EventConnection_somDestruct *somTD_EventComm_EventConnection_somDestruct;
typedef void   SOMLINK somTP_EventComm_EventConnection_somDefaultCopyInit(EventComm_EventConnection *somSelf, 
		som3InitCtrl* ctrl, 
		SOMObject* fromObj);
typedef somTP_EventComm_EventConnection_somDefaultCopyInit *somTD_EventComm_EventConnection_somDefaultCopyInit;
typedef EventComm_EventConnection*   SOMLINK somTP_EventComm_EventConnection_somDefaultAssign(EventComm_EventConnection *somSelf, 
		som3AssignCtrl* ctrl, 
		SOMObject* fromObj);
typedef somTP_EventComm_EventConnection_somDefaultAssign *somTD_EventComm_EventConnection_somDefaultAssign;
typedef void   SOMLINK somTP_EventComm_EventConnection_somDefaultConstCopyInit(EventComm_EventConnection *somSelf, 
		som3InitCtrl* ctrl, 
		SOMObject* fromObj);
typedef somTP_EventComm_EventConnection_somDefaultConstCopyInit *somTD_EventComm_EventConnection_somDefaultConstCopyInit;
typedef void   SOMLINK somTP_EventComm_EventConnection_somDefaultVCopyInit(EventComm_EventConnection *somSelf, 
		som3InitCtrl* ctrl, 
		SOMObject* fromObj);
typedef somTP_EventComm_EventConnection_somDefaultVCopyInit *somTD_EventComm_EventConnection_somDefaultVCopyInit;
typedef void   SOMLINK somTP_EventComm_EventConnection_somDefaultConstVCopyInit(EventComm_EventConnection *somSelf, 
		som3InitCtrl* ctrl, 
		SOMObject* fromObj);
typedef somTP_EventComm_EventConnection_somDefaultConstVCopyInit *somTD_EventComm_EventConnection_somDefaultConstVCopyInit;
typedef EventComm_EventConnection*   SOMLINK somTP_EventComm_EventConnection_somDefaultConstAssign(EventComm_EventConnection *somSelf, 
		som3AssignCtrl* ctrl, 
		SOMObject* fromObj);
typedef somTP_EventComm_EventConnection_somDefaultConstAssign *somTD_EventComm_EventConnection_somDefaultConstAssign;
typedef EventComm_EventConnection*   SOMLINK somTP_EventComm_EventConnection_somDefaultVAssign(EventComm_EventConnection *somSelf, 
		som3AssignCtrl* ctrl, 
		SOMObject* fromObj);
typedef somTP_EventComm_EventConnection_somDefaultVAssign *somTD_EventComm_EventConnection_somDefaultVAssign;
typedef EventComm_EventConnection*   SOMLINK somTP_EventComm_EventConnection_somDefaultConstVAssign(EventComm_EventConnection *somSelf, 
		som3AssignCtrl* ctrl, 
		SOMObject* fromObj);
typedef somTP_EventComm_EventConnection_somDefaultConstVAssign *somTD_EventComm_EventConnection_somDefaultConstVAssign;
typedef void   SOMLINK somTP_EventComm_EventConnection_somInit(EventComm_EventConnection *somSelf);
typedef somTP_EventComm_EventConnection_somInit *somTD_EventComm_EventConnection_somInit;
typedef void   SOMLINK somTP_EventComm_EventConnection_somUninit(EventComm_EventConnection *somSelf);
typedef somTP_EventComm_EventConnection_somUninit *somTD_EventComm_EventConnection_somUninit;
typedef void   SOMLINK somTP_EventComm_EventConnection_somFree(EventComm_EventConnection *somSelf);
typedef somTP_EventComm_EventConnection_somFree *somTD_EventComm_EventConnection_somFree;
typedef SOMClass*   SOMLINK somTP_EventComm_EventConnection_somGetClass(EventComm_EventConnection *somSelf);
typedef somTP_EventComm_EventConnection_somGetClass *somTD_EventComm_EventConnection_somGetClass;
typedef string   SOMLINK somTP_EventComm_EventConnection_somGetClassName(EventComm_EventConnection *somSelf);
typedef somTP_EventComm_EventConnection_somGetClassName *somTD_EventComm_EventConnection_somGetClassName;
typedef long   SOMLINK somTP_EventComm_EventConnection_somGetSize(EventComm_EventConnection *somSelf);
typedef somTP_EventComm_EventConnection_somGetSize *somTD_EventComm_EventConnection_somGetSize;
typedef boolean   SOMLINK somTP_EventComm_EventConnection_somIsA(EventComm_EventConnection *somSelf, 
		SOMClass* aClassObj);
typedef somTP_EventComm_EventConnection_somIsA *somTD_EventComm_EventConnection_somIsA;
typedef boolean   SOMLINK somTP_EventComm_EventConnection_somIsInstanceOf(EventComm_EventConnection *somSelf, 
		SOMClass* aClassObj);
typedef somTP_EventComm_EventConnection_somIsInstanceOf *somTD_EventComm_EventConnection_somIsInstanceOf;
typedef boolean   SOMLINK somTP_EventComm_EventConnection_somRespondsTo(EventComm_EventConnection *somSelf, 
		somId mId);
typedef somTP_EventComm_EventConnection_somRespondsTo *somTD_EventComm_EventConnection_somRespondsTo;
typedef boolean   SOMLINK somTP_EventComm_EventConnection_somDispatch(EventComm_EventConnection *somSelf, 
		somToken* retValue, 
		somId methodId, 
		va_list ap);
typedef somTP_EventComm_EventConnection_somDispatch *somTD_EventComm_EventConnection_somDispatch;
typedef boolean   SOMLINK somTP_EventComm_EventConnection_somClassDispatch(EventComm_EventConnection *somSelf, 
		SOMClass* clsObj, 
		somToken* retValue, 
		somId methodId, 
		va_list ap);
typedef somTP_EventComm_EventConnection_somClassDispatch *somTD_EventComm_EventConnection_somClassDispatch;
typedef boolean   SOMLINK somTP_EventComm_EventConnection_somCastObj(EventComm_EventConnection *somSelf, 
		SOMClass* castedCls);
typedef somTP_EventComm_EventConnection_somCastObj *somTD_EventComm_EventConnection_somCastObj;
typedef boolean   SOMLINK somTP_EventComm_EventConnection_somResetObj(EventComm_EventConnection *somSelf);
typedef somTP_EventComm_EventConnection_somResetObj *somTD_EventComm_EventConnection_somResetObj;
typedef EventComm_EventConnection*   SOMLINK somTP_EventComm_EventConnection_somPrintSelf(EventComm_EventConnection *somSelf);
typedef somTP_EventComm_EventConnection_somPrintSelf *somTD_EventComm_EventConnection_somPrintSelf;
typedef void   SOMLINK somTP_EventComm_EventConnection_somDumpSelf(EventComm_EventConnection *somSelf, 
		long level);
typedef somTP_EventComm_EventConnection_somDumpSelf *somTD_EventComm_EventConnection_somDumpSelf;
typedef void   SOMLINK somTP_EventComm_EventConnection_somDumpSelfInt(EventComm_EventConnection *somSelf, 
		long level);
typedef somTP_EventComm_EventConnection_somDumpSelfInt *somTD_EventComm_EventConnection_somDumpSelfInt;
}

#endif /* EventComm_EventConnection_API */


/*
 * -- The C++ Wrapper Class for EventComm_EventConnection
 */
class EventComm_EventConnection : public SOMObject
{
public:

// EventComm_EventConnection::new creates the class object if necessary, and then uses
// somNewNoInit to allocate memory and create the object.
// Initialization is in ctors.
void *operator new(size_t)
{
   if (!_EventComm_EventConnection) EventComm_EventConnectionNewClass(EventComm_EventConnection_MajorVersion,EventComm_EventConnection_MinorVersion);
   return (void*)
   (((somTD_SOMClass_somNewNoInit)(SOMClassClassData.somNewNoInit))
         ((SOMClass *)((void*)_EventComm_EventConnection)));
}

// EventComm_EventConnection::delete uses somFree.
void operator delete(void * obj)
{
   if (obj && *(void**)obj)
      ((SOMObject*)obj)->somFree();
}

EventComm_EventConnection& operator=(EventComm_EventConnection& fromObj)
{
   this->somDefaultAssign(0,(SOMObject*)((void*)&fromObj));
   return *this;
}

EventComm_EventConnection()
{
   if (*(void**)this != (EventComm_EventConnectionCClassData.parentMtab)->mtab)
      return;
   ((SOMObject*)((void*)this))->somDefaultInit(0);
}

EventComm_EventConnection(EventComm_EventConnection* fromObj)
{
   if (*(void**)this != (EventComm_EventConnectionCClassData.parentMtab)->mtab)
      return;
   ((SOMObject*)((void*)this))->somDefaultCopyInit(0,((SOMObject*)((void*)fromObj)));
}


/* method: disconnect */
void   disconnect(Environment *ev)
{
   	(
	 SOM_TestCls(this,_SOMCLASS_EventComm_EventConnection),
	 ((somTD_EventComm_EventConnection_disconnect)(EventComm_EventConnectionClassData.disconnect))(((EventComm_EventConnection *)((void *)this)), ev)
	);
}


/*
 * Reintroduce inherited methods
 */

/* initializer method: somDefaultInit */
void   somDefaultInit(som3InitCtrl* ctrl)
{
/*
 *  A default initializer for a SOM object. Passing a null ctrl
 *  indicates to the receiver that its class is the class of the
 *  object being initialized, whereby the initializer will determine
 *  an appropriate control structure.
 */
   	(
	 SOM_TestCls(this,_SOMCLASS_SOMObject),
	 ((somTD_EventComm_EventConnection_somDefaultInit)(SOMObjectClassData.somDefaultInit))(((EventComm_EventConnection *)((void *)this)),ctrl)
	);
}


/* method: somDestruct */
void   somDestruct(octet doFree, 
		som3DestructCtrl* ctrl)
{
/*
 *  The default destructor for a SOM object. A nonzero <doFree>
 *  indicates that the object storage should be freed by the
 *  object's class (via somDeallocate) after uninitialization.
 *  As with somDefaultInit, a null ctrl can be passed.
 */
   	(
	 SOM_TestCls(this,_SOMCLASS_SOMObject),
	 ((somTD_EventComm_EventConnection_somDestruct)(SOMObjectClassData.somDestruct))(((EventComm_EventConnection *)((void *)this)),doFree,ctrl)
	);
}


/* initializer method: somDefaultCopyInit */
void   somDefaultCopyInit(som3InitCtrl* ctrl, 
		SOMObject* fromObj)
{
/*
 *  A default copy constructor. Use this to make copies of objects for
 *  calling methods with "by-value" argument semantics.
 */
   	(
	 SOM_TestCls(this,_SOMCLASS_SOMObject),
	 ((somTD_EventComm_EventConnection_somDefaultCopyInit)(SOMObjectClassData.somDefaultCopyInit))(((EventComm_EventConnection *)((void *)this)),ctrl,fromObj)
	);
}


/* method: somDefaultAssign */
EventComm_EventConnection*  somDefaultAssign(som3AssignCtrl* ctrl, 
		SOMObject* fromObj)
{
/*
 *  A default assignment operator. Use this to "assign" the state of one
 *  object to another.
 */
   return 	(
	 SOM_TestCls(this,_SOMCLASS_SOMObject),
	 ((somTD_EventComm_EventConnection_somDefaultAssign)(SOMObjectClassData.somDefaultAssign))(((EventComm_EventConnection *)((void *)this)),ctrl,fromObj)
	);
}


/* initializer method: somDefaultConstCopyInit */
void   somDefaultConstCopyInit(som3InitCtrl* ctrl, 
		SOMObject* fromObj)
{
/*
 *  A default copy constructor that uses a const fromObj.
 */
   	(
	 SOM_TestCls(this,_SOMCLASS_SOMObject),
	 ((somTD_EventComm_EventConnection_somDefaultConstCopyInit)(SOMObjectClassData.somDefaultConstCopyInit))(((EventComm_EventConnection *)((void *)this)),ctrl,fromObj)
	);
}


/* initializer method: somDefaultVCopyInit */
void   somDefaultVCopyInit(som3InitCtrl* ctrl, 
		SOMObject* fromObj)
{
/*
 *  A default copy constructor that uses a volatile fromObj.
 */
   	(
	 SOM_TestCls(this,_SOMCLASS_SOMObject),
	 ((somTD_EventComm_EventConnection_somDefaultVCopyInit)(SOMObjectClassData.somDefaultVCopyInit))(((EventComm_EventConnection *)((void *)this)),ctrl,fromObj)
	);
}


/* initializer method: somDefaultConstVCopyInit */
void   somDefaultConstVCopyInit(som3InitCtrl* ctrl, 
		SOMObject* fromObj)
{
/*
 *  A default copy constructor that uses a const volatile fromObj.
 */
   	(
	 SOM_TestCls(this,_SOMCLASS_SOMObject),
	 ((somTD_EventComm_EventConnection_somDefaultConstVCopyInit)(SOMObjectClassData.somDefaultConstVCopyInit))(((EventComm_EventConnection *)((void *)this)),ctrl,fromObj)
	);
}


/* method: somDefaultConstAssign */
EventComm_EventConnection*  somDefaultConstAssign(som3AssignCtrl* ctrl, 
		SOMObject* fromObj)
{
/*
 *  A default assignment operator that uses a const fromObj.
 */
   return 	(
	 SOM_TestCls(this,_SOMCLASS_SOMObject),
	 ((somTD_EventComm_EventConnection_somDefaultConstAssign)(SOMObjectClassData.somDefaultConstAssign))(((EventComm_EventConnection *)((void *)this)),ctrl,fromObj)
	);
}


/* method: somDefaultVAssign */
EventComm_EventConnection*  somDefaultVAssign(som3AssignCtrl* ctrl, 
		SOMObject* fromObj)
{
/*
 *  A default assignment operator that uses a volatile fromObj.
 */
   return 	(
	 SOM_TestCls(this,_SOMCLASS_SOMObject),
	 ((somTD_EventComm_EventConnection_somDefaultVAssign)(SOMObjectClassData.somDefaultVAssign))(((EventComm_EventConnection *)((void *)this)),ctrl,fromObj)
	);
}


/* method: somDefaultConstVAssign */
EventComm_EventConnection*  somDefaultConstVAssign(som3AssignCtrl* ctrl, 
		SOMObject* fromObj)
{
/*
 *  A default assignment operator that uses a const volatile fromObj.
 */
   return 	(
	 SOM_TestCls(this,_SOMCLASS_SOMObject),
	 ((somTD_EventComm_EventConnection_somDefaultConstVAssign)(SOMObjectClassData.somDefaultConstVAssign))(((EventComm_EventConnection *)((void *)this)),ctrl,fromObj)
	);
}


/* method: somInit */
void   somInit()
{
/*
 *  Obsolete but still supported. Override somDefaultInit instead of somInit.
 */
   	(
	 SOM_TestCls(this,_SOMCLASS_SOMObject),
	 ((somTD_EventComm_EventConnection_somInit)(SOMObjectClassData.somInit))(((EventComm_EventConnection *)((void *)this)))
	);
}


/* method: somUninit */
void   somUninit()
{
/*
 *  Obsolete but still supported. Override somDestruct instead of somUninit.
 */
   	(
	 SOM_TestCls(this,_SOMCLASS_SOMObject),
	 ((somTD_EventComm_EventConnection_somUninit)(SOMObjectClassData.somUninit))(((EventComm_EventConnection *)((void *)this)))
	);
}


/* method: somFree */
void   somFree()
{
/*
 *  The default implementation just calls somDestruct.
 */
   	(
	 SOM_TestCls(this,_SOMCLASS_SOMObject),
	 ((somTD_EventComm_EventConnection_somFree)(SOMObjectClassData.somFree))(((EventComm_EventConnection *)((void *)this)))
	);
}


/* method: somGetClass */
SOMClass*   somGetClass()
{
/*
 *  Return the receiver's class.
 */
   return 	(
	 SOM_TestCls(this,_SOMCLASS_SOMObject),
	 ((somTD_EventComm_EventConnection_somGetClass)(SOMObjectClassData.somGetClass))(((EventComm_EventConnection *)((void *)this)))
	);
}


/* method: somGetClassName */
string   somGetClassName()
{
/*
 *  Return the name of the receiver's class.
 */
   return 	(
	 SOM_TestCls(this,_SOMCLASS_SOMObject),
	 ((somTD_EventComm_EventConnection_somGetClassName)(SOMObjectClassData.somGetClassName))(((EventComm_EventConnection *)((void *)this)))
	);
}


/* method: somGetSize */
long   somGetSize()
{
/*
 *  Return the size of the receiver.
 */
   return 	(
	 SOM_TestCls(this,_SOMCLASS_SOMObject),
	 ((somTD_EventComm_EventConnection_somGetSize)(SOMObjectClassData.somGetSize))(((EventComm_EventConnection *)((void *)this)))
	);
}


/* method: somIsA */
boolean   somIsA(SOMClass* aClassObj)
{
/*
 *  Returns 1 (true) if the receiver responds to methods
 *  introduced by <aClassObj>, and 0 (false) otherwise.
 */
   return 	(
	 SOM_TestCls(this,_SOMCLASS_SOMObject),
	 ((somTD_EventComm_EventConnection_somIsA)(SOMObjectClassData.somIsA))(((EventComm_EventConnection *)((void *)this)),aClassObj)
	);
}


/* method: somIsInstanceOf */
boolean   somIsInstanceOf(SOMClass* aClassObj)
{
/*
 *  Returns 1 (true) if the receiver is an instance of
 *  <aClassObj> and 0 (false) otherwise.
 */
   return 	(
	 SOM_TestCls(this,_SOMCLASS_SOMObject),
	 ((somTD_EventComm_EventConnection_somIsInstanceOf)(SOMObjectClassData.somIsInstanceOf))(((EventComm_EventConnection *)((void *)this)),aClassObj)
	);
}


/* method: somRespondsTo */
boolean   somRespondsTo(somId mId)
{
/*
 *  Returns 1 (true) if the indicated method can be invoked
 *  on the receiver and 0 (false) otherwise.
 */
   return 	(
	 SOM_TestCls(this,_SOMCLASS_SOMObject),
	 ((somTD_EventComm_EventConnection_somRespondsTo)(SOMObjectClassData.somRespondsTo))(((EventComm_EventConnection *)((void *)this)),mId)
	);
}


/* va_list method: somDispatch */

/*
 *  This method provides a generic, class-specific dispatch mechanism.
 *  It accepts as input <retValue> a pointer to the memory area to be
 *  loaded with the result of dispatching the method indicated by
 *  <methodId> using the arguments in <ap>. <ap> contains the object
 *  on which the method is to be invoked as the first argument.
 * 
 *  Default redispatch stubs invoke this method.
 */
/* the va_list invocation form */
boolean   SOMObject_somDispatch(somToken* retValue, 
		somId methodId, 
		va_list ap)
{   return 	(
	 SOM_TestCls(this,_SOMCLASS_SOMObject),
	 ((somTD_EventComm_EventConnection_somDispatch)(SOMObjectClassData.somDispatch))(((EventComm_EventConnection *)((void *)this)),retValue,methodId,ap)
	);
}

/* the varargs invocation form */
boolean   somDispatch(somToken* retValue, 
		somId methodId, 
		...)
{
/*
 *  This method provides a generic, class-specific dispatch mechanism.
 *  It accepts as input <retValue> a pointer to the memory area to be
 *  loaded with the result of dispatching the method indicated by
 *  <methodId> using the arguments in <ap>. <ap> contains the object
 *  on which the method is to be invoked as the first argument.
 * 
 *  Default redispatch stubs invoke this method.
 */
   va_list ap;
   va_start(ap, methodId);
   boolean __somResult = 
      	(
	 SOM_TestCls(this,_SOMCLASS_SOMObject),
	 ((somTD_EventComm_EventConnection_somDispatch)(SOMObjectClassData.somDispatch))(((EventComm_EventConnection *)((void *)this)),retValue,methodId,ap)
	);
   va_end(ap);
   return __somResult;
}


/* va_list method: somClassDispatch */

/*
 *  Like somDispatch, but method resolution for static methods is done
 *  according to the clsObj instance method table.
 */
/* the va_list invocation form */
boolean   SOMObject_somClassDispatch(SOMClass* clsObj, 
		somToken* retValue, 
		somId methodId, 
		va_list ap)
{   return 	(
	 SOM_TestCls(this,_SOMCLASS_SOMObject),
	 ((somTD_EventComm_EventConnection_somClassDispatch)(SOMObjectClassData.somClassDispatch))(((EventComm_EventConnection *)((void *)this)),clsObj,retValue,methodId,ap)
	);
}

/* the varargs invocation form */
boolean   somClassDispatch(SOMClass* clsObj, 
		somToken* retValue, 
		somId methodId, 
		...)
{
/*
 *  Like somDispatch, but method resolution for static methods is done
 *  according to the clsObj instance method table.
 */
   va_list ap;
   va_start(ap, methodId);
   boolean __somResult = 
      	(
	 SOM_TestCls(this,_SOMCLASS_SOMObject),
	 ((somTD_EventComm_EventConnection_somClassDispatch)(SOMObjectClassData.somClassDispatch))(((EventComm_EventConnection *)((void *)this)),clsObj,retValue,methodId,ap)
	);
   va_end(ap);
   return __somResult;
}


/* method: somCastObj */
boolean   somCastObj(SOMClass* castedCls)
{
/*
 *  Changes the behavior of the target object to that implemented
 *  by castedCls. This is possible when all concrete data in castedCls
 *  is also concrete in the true class of the target object.
 *  Returns true (1) on success, and false (0) otherwise.
 */
   return 	(
	 SOM_TestCls(this,_SOMCLASS_SOMObject),
	 ((somTD_EventComm_EventConnection_somCastObj)(SOMObjectClassData.somCastObj))(((EventComm_EventConnection *)((void *)this)),castedCls)
	);
}


/* method: somResetObj */
boolean   somResetObj()
{
/*
 *  reset an object to its true class. Returns true always.
 */
   return 	(
	 SOM_TestCls(this,_SOMCLASS_SOMObject),
	 ((somTD_EventComm_EventConnection_somResetObj)(SOMObjectClassData.somResetObj))(((EventComm_EventConnection *)((void *)this)))
	);
}


/* method: somPrintSelf */
EventComm_EventConnection*  somPrintSelf()
{
/*
 *  Uses <SOMOutCharRoutine> to write a brief string with identifying
 *  information about this object.  The default implementation just gives
 *  the object's class name and its address in memory.
 *  <self> is returned.
 */
   return 	(
	 SOM_TestCls(this,_SOMCLASS_SOMObject),
	 ((somTD_EventComm_EventConnection_somPrintSelf)(SOMObjectClassData.somPrintSelf))(((EventComm_EventConnection *)((void *)this)))
	);
}


/* method: somDumpSelf */
void   somDumpSelf(long level)
{
/*
 *  Uses <SOMOutCharRoutine> to write a detailed description of this object
 *  and its current state.
 * 
 *  <level> indicates the nesting level for describing compound objects
 *  it must be greater than or equal to zero.  All lines in the
 *  description will be preceeded by <2*level> spaces.
 * 
 *  This routine only actually writes the data that concerns the object
 *  as a whole, such as class, and uses <somDumpSelfInt> to describe
 *  the object's current state.  This approach allows readable
 *  descriptions of compound objects to be constructed.
 * 
 *  Generally it is not necessary to override this method, if it is
 *  overriden it generally must be completely replaced.
 */
   	(
	 SOM_TestCls(this,_SOMCLASS_SOMObject),
	 ((somTD_EventComm_EventConnection_somDumpSelf)(SOMObjectClassData.somDumpSelf))(((EventComm_EventConnection *)((void *)this)),level)
	);
}


/* method: somDumpSelfInt */
void   somDumpSelfInt(long level)
{
/*
 *  Uses <SOMOutCharRoutine> to write in the current state of this object.
 *  Generally this method will need to be overridden.  When overriding
 *  it, begin by calling the parent class form of this method and then
 *  write in a description of your class's instance data. This will
 *  result in a description of all the object's instance data going
 *  from its root ancestor class to its specific class.
 */
   	(
	 SOM_TestCls(this,_SOMCLASS_SOMObject),
	 ((somTD_EventComm_EventConnection_somDumpSelfInt)(SOMObjectClassData.somDumpSelfInt))(((EventComm_EventConnection *)((void *)this)),level)
	);
}



};   /* EventComm_EventConnection */



#endif       /* SOM_EventComm_EventConnection_xh */

#ifndef SOM_EventComm_Consumer_xh
#define SOM_EventComm_Consumer_xh


#define EventComm_Consumer_MajorVersion 1
#define EventComm_Consumer_MinorVersion 1
class EventComm_Consumer;

/* Parents */
#ifndef SOM_EventComm_EventConnection_xh
#ifdef SOMLOCALINCLUDES
#include "eventcom.xh"
#else
#include <eventcom.xh>
#endif
#endif

/* Useful C++ SOM defs */
#include <somcls.xh>
#include <somcm.xh>

#ifndef EventComm_Consumer_API
#define EventComm_Consumer_API
/*
 * -- The Class API
 */

/*
 * Start of bindings for IDL types
 */


/*
 * End of bindings for IDL types.
 */

/*
 * A function to create the EventComm_Consumer class object...
 */
SOMEXTERN SOM_IMPORTEXPORT_event_eventcom SOMClass * SOMLINK EventComm_ConsumerNewClass(
		integer4 majorVersion,
		integer4 minorVersion);


/*
 * The API 2 ClassData Structures...
 */
SOMEXTERN struct EventComm_ConsumerClassDataStructure {
	SOMClass *classObject;
	somMToken push;
	somMToken _get_ev_con;
	somMToken _set_ev_con;
} SOMDLINK SOM_IMPORTEXPORT_event_eventcom EventComm_ConsumerClassData;
SOMEXTERN struct EventComm_ConsumerCClassDataStructure {
	som3ClassDetailsPtr    parentMtab;
	somDToken              instanceDataToken;
} SOMDLINK SOM_IMPORTEXPORT_event_eventcom EventComm_ConsumerCClassData;


/*
 * Class Object and Method Token Macros
 */
#define _SOMCLASS_EventComm_Consumer (EventComm_ConsumerClassData.classObject)
#ifndef SOMGD_EventComm_Consumer
    #if (defined(_EventComm_Consumer) || defined(__EventComm_Consumer))
        #undef _EventComm_Consumer
        #undef __EventComm_Consumer
        #define SOMGD_EventComm_Consumer 1
    #else
        #define _EventComm_Consumer _SOMCLASS_EventComm_Consumer
    #endif /* _EventComm_Consumer */
#endif /* SOMGD_EventComm_Consumer */
#define EventComm_Consumer_classObj _SOMCLASS_EventComm_Consumer
#define _SOMMTOKEN_EventComm_Consumer(method) ((somMToken)EventComm_ConsumerClassData.method)

/*
 * -- Typedefs for EventComm_Consumer Method Procedures
 */
SOMEXTERN {
typedef EventComm_EventConnection*   SOMLINK somTP_EventComm_Consumer__get_ev_con(EventComm_Consumer *somSelf, Environment *ev);
typedef somTP_EventComm_Consumer__get_ev_con *somTD_EventComm_Consumer__get_ev_con;
typedef void   SOMLINK somTP_EventComm_Consumer__set_ev_con(EventComm_Consumer *somSelf, Environment *ev, 
		EventComm_EventConnection* ev_con);
typedef somTP_EventComm_Consumer__set_ev_con *somTD_EventComm_Consumer__set_ev_con;
typedef void   SOMLINK somTP_EventComm_Consumer_push(EventComm_Consumer *somSelf, Environment *ev, 
		any* event_data);
typedef somTP_EventComm_Consumer_push *somTD_EventComm_Consumer_push;

/*
 * -- Typedefs for Reintroduced Wrapper Methods
 */
typedef void   SOMLINK somTP_EventComm_Consumer_disconnect(EventComm_Consumer *somSelf, Environment *ev);
typedef somTP_EventComm_Consumer_disconnect *somTD_EventComm_Consumer_disconnect;
typedef void   SOMLINK somTP_EventComm_Consumer_somDefaultInit(EventComm_Consumer *somSelf, 
		som3InitCtrl* ctrl);
typedef somTP_EventComm_Consumer_somDefaultInit *somTD_EventComm_Consumer_somDefaultInit;
typedef void   SOMLINK somTP_EventComm_Consumer_somDestruct(EventComm_Consumer *somSelf, 
		octet doFree, 
		som3DestructCtrl* ctrl);
typedef somTP_EventComm_Consumer_somDestruct *somTD_EventComm_Consumer_somDestruct;
typedef void   SOMLINK somTP_EventComm_Consumer_somDefaultCopyInit(EventComm_Consumer *somSelf, 
		som3InitCtrl* ctrl, 
		SOMObject* fromObj);
typedef somTP_EventComm_Consumer_somDefaultCopyInit *somTD_EventComm_Consumer_somDefaultCopyInit;
typedef EventComm_Consumer*   SOMLINK somTP_EventComm_Consumer_somDefaultAssign(EventComm_Consumer *somSelf, 
		som3AssignCtrl* ctrl, 
		SOMObject* fromObj);
typedef somTP_EventComm_Consumer_somDefaultAssign *somTD_EventComm_Consumer_somDefaultAssign;
typedef void   SOMLINK somTP_EventComm_Consumer_somDefaultConstCopyInit(EventComm_Consumer *somSelf, 
		som3InitCtrl* ctrl, 
		SOMObject* fromObj);
typedef somTP_EventComm_Consumer_somDefaultConstCopyInit *somTD_EventComm_Consumer_somDefaultConstCopyInit;
typedef void   SOMLINK somTP_EventComm_Consumer_somDefaultVCopyInit(EventComm_Consumer *somSelf, 
		som3InitCtrl* ctrl, 
		SOMObject* fromObj);
typedef somTP_EventComm_Consumer_somDefaultVCopyInit *somTD_EventComm_Consumer_somDefaultVCopyInit;
typedef void   SOMLINK somTP_EventComm_Consumer_somDefaultConstVCopyInit(EventComm_Consumer *somSelf, 
		som3InitCtrl* ctrl, 
		SOMObject* fromObj);
typedef somTP_EventComm_Consumer_somDefaultConstVCopyInit *somTD_EventComm_Consumer_somDefaultConstVCopyInit;
typedef EventComm_Consumer*   SOMLINK somTP_EventComm_Consumer_somDefaultConstAssign(EventComm_Consumer *somSelf, 
		som3AssignCtrl* ctrl, 
		SOMObject* fromObj);
typedef somTP_EventComm_Consumer_somDefaultConstAssign *somTD_EventComm_Consumer_somDefaultConstAssign;
typedef EventComm_Consumer*   SOMLINK somTP_EventComm_Consumer_somDefaultVAssign(EventComm_Consumer *somSelf, 
		som3AssignCtrl* ctrl, 
		SOMObject* fromObj);
typedef somTP_EventComm_Consumer_somDefaultVAssign *somTD_EventComm_Consumer_somDefaultVAssign;
typedef EventComm_Consumer*   SOMLINK somTP_EventComm_Consumer_somDefaultConstVAssign(EventComm_Consumer *somSelf, 
		som3AssignCtrl* ctrl, 
		SOMObject* fromObj);
typedef somTP_EventComm_Consumer_somDefaultConstVAssign *somTD_EventComm_Consumer_somDefaultConstVAssign;
typedef void   SOMLINK somTP_EventComm_Consumer_somInit(EventComm_Consumer *somSelf);
typedef somTP_EventComm_Consumer_somInit *somTD_EventComm_Consumer_somInit;
typedef void   SOMLINK somTP_EventComm_Consumer_somUninit(EventComm_Consumer *somSelf);
typedef somTP_EventComm_Consumer_somUninit *somTD_EventComm_Consumer_somUninit;
typedef void   SOMLINK somTP_EventComm_Consumer_somFree(EventComm_Consumer *somSelf);
typedef somTP_EventComm_Consumer_somFree *somTD_EventComm_Consumer_somFree;
typedef SOMClass*   SOMLINK somTP_EventComm_Consumer_somGetClass(EventComm_Consumer *somSelf);
typedef somTP_EventComm_Consumer_somGetClass *somTD_EventComm_Consumer_somGetClass;
typedef string   SOMLINK somTP_EventComm_Consumer_somGetClassName(EventComm_Consumer *somSelf);
typedef somTP_EventComm_Consumer_somGetClassName *somTD_EventComm_Consumer_somGetClassName;
typedef long   SOMLINK somTP_EventComm_Consumer_somGetSize(EventComm_Consumer *somSelf);
typedef somTP_EventComm_Consumer_somGetSize *somTD_EventComm_Consumer_somGetSize;
typedef boolean   SOMLINK somTP_EventComm_Consumer_somIsA(EventComm_Consumer *somSelf, 
		SOMClass* aClassObj);
typedef somTP_EventComm_Consumer_somIsA *somTD_EventComm_Consumer_somIsA;
typedef boolean   SOMLINK somTP_EventComm_Consumer_somIsInstanceOf(EventComm_Consumer *somSelf, 
		SOMClass* aClassObj);
typedef somTP_EventComm_Consumer_somIsInstanceOf *somTD_EventComm_Consumer_somIsInstanceOf;
typedef boolean   SOMLINK somTP_EventComm_Consumer_somRespondsTo(EventComm_Consumer *somSelf, 
		somId mId);
typedef somTP_EventComm_Consumer_somRespondsTo *somTD_EventComm_Consumer_somRespondsTo;
typedef boolean   SOMLINK somTP_EventComm_Consumer_somDispatch(EventComm_Consumer *somSelf, 
		somToken* retValue, 
		somId methodId, 
		va_list ap);
typedef somTP_EventComm_Consumer_somDispatch *somTD_EventComm_Consumer_somDispatch;
typedef boolean   SOMLINK somTP_EventComm_Consumer_somClassDispatch(EventComm_Consumer *somSelf, 
		SOMClass* clsObj, 
		somToken* retValue, 
		somId methodId, 
		va_list ap);
typedef somTP_EventComm_Consumer_somClassDispatch *somTD_EventComm_Consumer_somClassDispatch;
typedef boolean   SOMLINK somTP_EventComm_Consumer_somCastObj(EventComm_Consumer *somSelf, 
		SOMClass* castedCls);
typedef somTP_EventComm_Consumer_somCastObj *somTD_EventComm_Consumer_somCastObj;
typedef boolean   SOMLINK somTP_EventComm_Consumer_somResetObj(EventComm_Consumer *somSelf);
typedef somTP_EventComm_Consumer_somResetObj *somTD_EventComm_Consumer_somResetObj;
typedef EventComm_Consumer*   SOMLINK somTP_EventComm_Consumer_somPrintSelf(EventComm_Consumer *somSelf);
typedef somTP_EventComm_Consumer_somPrintSelf *somTD_EventComm_Consumer_somPrintSelf;
typedef void   SOMLINK somTP_EventComm_Consumer_somDumpSelf(EventComm_Consumer *somSelf, 
		long level);
typedef somTP_EventComm_Consumer_somDumpSelf *somTD_EventComm_Consumer_somDumpSelf;
typedef void   SOMLINK somTP_EventComm_Consumer_somDumpSelfInt(EventComm_Consumer *somSelf, 
		long level);
typedef somTP_EventComm_Consumer_somDumpSelfInt *somTD_EventComm_Consumer_somDumpSelfInt;
}

#endif /* EventComm_Consumer_API */


/*
 * -- The C++ Wrapper Class for EventComm_Consumer
 */
class EventComm_Consumer : public EventComm_EventConnection
{
public:

// EventComm_Consumer::new creates the class object if necessary, and then uses
// somNewNoInit to allocate memory and create the object.
// Initialization is in ctors.
void *operator new(size_t)
{
   if (!_EventComm_Consumer) EventComm_ConsumerNewClass(EventComm_Consumer_MajorVersion,EventComm_Consumer_MinorVersion);
   return (void*)
   (((somTD_SOMClass_somNewNoInit)(SOMClassClassData.somNewNoInit))
         ((SOMClass *)((void*)_EventComm_Consumer)));
}

// EventComm_Consumer::delete uses somFree.
void operator delete(void * obj)
{
   if (obj && *(void**)obj)
      ((SOMObject*)obj)->somFree();
}

EventComm_Consumer& operator=(EventComm_Consumer& fromObj)
{
   this->somDefaultAssign(0,(SOMObject*)((void*)&fromObj));
   return *this;
}

EventComm_Consumer()
{
   if (*(void**)this != (EventComm_ConsumerCClassData.parentMtab)->mtab)
      return;
   ((SOMObject*)((void*)this))->somDefaultInit(0);
}

EventComm_Consumer(EventComm_Consumer* fromObj)
{
   if (*(void**)this != (EventComm_ConsumerCClassData.parentMtab)->mtab)
      return;
   ((SOMObject*)((void*)this))->somDefaultCopyInit(0,((SOMObject*)((void*)fromObj)));
}


/* method: _get_ev_con */
EventComm_EventConnection*   _get_ev_con(Environment *ev)
{
/*
 * Method from the IDL attribute statement:
 * "attribute EventComm_EventConnection* ev_con"
 */
   return 	(
	 SOM_TestCls(this,_SOMCLASS_EventComm_Consumer),
	 ((somTD_EventComm_Consumer__get_ev_con)(EventComm_ConsumerClassData._get_ev_con))(((EventComm_Consumer *)((void *)this)), ev)
	);
}


/* method: _set_ev_con */
void   _set_ev_con(Environment *ev, 
		EventComm_EventConnection* ev_con)
{
/*
 * Method from the IDL attribute statement:
 * "attribute EventComm_EventConnection* ev_con"
 */
   	(
	 SOM_TestCls(this,_SOMCLASS_EventComm_Consumer),
	 ((somTD_EventComm_Consumer__set_ev_con)(EventComm_ConsumerClassData._set_ev_con))(((EventComm_Consumer *)((void *)this)), ev,ev_con)
	);
}


/* method: push */
void   push(Environment *ev, 
		any* event_data)
{
   	(
	 SOM_TestCls(this,_SOMCLASS_EventComm_Consumer),
	 ((somTD_EventComm_Consumer_push)(EventComm_ConsumerClassData.push))(((EventComm_Consumer *)((void *)this)), ev,event_data)
	);
}


/*
 * Reintroduce inherited methods
 */

/* method: disconnect */
void   disconnect(Environment *ev)
{
   	(
	 SOM_TestCls(this,_SOMCLASS_EventComm_EventConnection),
	 ((somTD_EventComm_Consumer_disconnect)(EventComm_EventConnectionClassData.disconnect))(((EventComm_Consumer *)((void *)this)), ev)
	);
}


/* initializer method: somDefaultInit */
void   somDefaultInit(som3InitCtrl* ctrl)
{
/*
 *  A default initializer for a SOM object. Passing a null ctrl
 *  indicates to the receiver that its class is the class of the
 *  object being initialized, whereby the initializer will determine
 *  an appropriate control structure.
 */
   	(
	 SOM_TestCls(this,_SOMCLASS_SOMObject),
	 ((somTD_EventComm_Consumer_somDefaultInit)(SOMObjectClassData.somDefaultInit))(((EventComm_Consumer *)((void *)this)),ctrl)
	);
}


/* method: somDestruct */
void   somDestruct(octet doFree, 
		som3DestructCtrl* ctrl)
{
/*
 *  The default destructor for a SOM object. A nonzero <doFree>
 *  indicates that the object storage should be freed by the
 *  object's class (via somDeallocate) after uninitialization.
 *  As with somDefaultInit, a null ctrl can be passed.
 */
   	(
	 SOM_TestCls(this,_SOMCLASS_SOMObject),
	 ((somTD_EventComm_Consumer_somDestruct)(SOMObjectClassData.somDestruct))(((EventComm_Consumer *)((void *)this)),doFree,ctrl)
	);
}


/* initializer method: somDefaultCopyInit */
void   somDefaultCopyInit(som3InitCtrl* ctrl, 
		SOMObject* fromObj)
{
/*
 *  A default copy constructor. Use this to make copies of objects for
 *  calling methods with "by-value" argument semantics.
 */
   	(
	 SOM_TestCls(this,_SOMCLASS_SOMObject),
	 ((somTD_EventComm_Consumer_somDefaultCopyInit)(SOMObjectClassData.somDefaultCopyInit))(((EventComm_Consumer *)((void *)this)),ctrl,fromObj)
	);
}


/* method: somDefaultAssign */
EventComm_Consumer*  somDefaultAssign(som3AssignCtrl* ctrl, 
		SOMObject* fromObj)
{
/*
 *  A default assignment operator. Use this to "assign" the state of one
 *  object to another.
 */
   return 	(
	 SOM_TestCls(this,_SOMCLASS_SOMObject),
	 ((somTD_EventComm_Consumer_somDefaultAssign)(SOMObjectClassData.somDefaultAssign))(((EventComm_Consumer *)((void *)this)),ctrl,fromObj)
	);
}


/* initializer method: somDefaultConstCopyInit */
void   somDefaultConstCopyInit(som3InitCtrl* ctrl, 
		SOMObject* fromObj)
{
/*
 *  A default copy constructor that uses a const fromObj.
 */
   	(
	 SOM_TestCls(this,_SOMCLASS_SOMObject),
	 ((somTD_EventComm_Consumer_somDefaultConstCopyInit)(SOMObjectClassData.somDefaultConstCopyInit))(((EventComm_Consumer *)((void *)this)),ctrl,fromObj)
	);
}


/* initializer method: somDefaultVCopyInit */
void   somDefaultVCopyInit(som3InitCtrl* ctrl, 
		SOMObject* fromObj)
{
/*
 *  A default copy constructor that uses a volatile fromObj.
 */
   	(
	 SOM_TestCls(this,_SOMCLASS_SOMObject),
	 ((somTD_EventComm_Consumer_somDefaultVCopyInit)(SOMObjectClassData.somDefaultVCopyInit))(((EventComm_Consumer *)((void *)this)),ctrl,fromObj)
	);
}


/* initializer method: somDefaultConstVCopyInit */
void   somDefaultConstVCopyInit(som3InitCtrl* ctrl, 
		SOMObject* fromObj)
{
/*
 *  A default copy constructor that uses a const volatile fromObj.
 */
   	(
	 SOM_TestCls(this,_SOMCLASS_SOMObject),
	 ((somTD_EventComm_Consumer_somDefaultConstVCopyInit)(SOMObjectClassData.somDefaultConstVCopyInit))(((EventComm_Consumer *)((void *)this)),ctrl,fromObj)
	);
}


/* method: somDefaultConstAssign */
EventComm_Consumer*  somDefaultConstAssign(som3AssignCtrl* ctrl, 
		SOMObject* fromObj)
{
/*
 *  A default assignment operator that uses a const fromObj.
 */
   return 	(
	 SOM_TestCls(this,_SOMCLASS_SOMObject),
	 ((somTD_EventComm_Consumer_somDefaultConstAssign)(SOMObjectClassData.somDefaultConstAssign))(((EventComm_Consumer *)((void *)this)),ctrl,fromObj)
	);
}


/* method: somDefaultVAssign */
EventComm_Consumer*  somDefaultVAssign(som3AssignCtrl* ctrl, 
		SOMObject* fromObj)
{
/*
 *  A default assignment operator that uses a volatile fromObj.
 */
   return 	(
	 SOM_TestCls(this,_SOMCLASS_SOMObject),
	 ((somTD_EventComm_Consumer_somDefaultVAssign)(SOMObjectClassData.somDefaultVAssign))(((EventComm_Consumer *)((void *)this)),ctrl,fromObj)
	);
}


/* method: somDefaultConstVAssign */
EventComm_Consumer*  somDefaultConstVAssign(som3AssignCtrl* ctrl, 
		SOMObject* fromObj)
{
/*
 *  A default assignment operator that uses a const volatile fromObj.
 */
   return 	(
	 SOM_TestCls(this,_SOMCLASS_SOMObject),
	 ((somTD_EventComm_Consumer_somDefaultConstVAssign)(SOMObjectClassData.somDefaultConstVAssign))(((EventComm_Consumer *)((void *)this)),ctrl,fromObj)
	);
}


/* method: somInit */
void   somInit()
{
/*
 *  Obsolete but still supported. Override somDefaultInit instead of somInit.
 */
   	(
	 SOM_TestCls(this,_SOMCLASS_SOMObject),
	 ((somTD_EventComm_Consumer_somInit)(SOMObjectClassData.somInit))(((EventComm_Consumer *)((void *)this)))
	);
}


/* method: somUninit */
void   somUninit()
{
/*
 *  Obsolete but still supported. Override somDestruct instead of somUninit.
 */
   	(
	 SOM_TestCls(this,_SOMCLASS_SOMObject),
	 ((somTD_EventComm_Consumer_somUninit)(SOMObjectClassData.somUninit))(((EventComm_Consumer *)((void *)this)))
	);
}


/* method: somFree */
void   somFree()
{
/*
 *  The default implementation just calls somDestruct.
 */
   	(
	 SOM_TestCls(this,_SOMCLASS_SOMObject),
	 ((somTD_EventComm_Consumer_somFree)(SOMObjectClassData.somFree))(((EventComm_Consumer *)((void *)this)))
	);
}


/* method: somGetClass */
SOMClass*   somGetClass()
{
/*
 *  Return the receiver's class.
 */
   return 	(
	 SOM_TestCls(this,_SOMCLASS_SOMObject),
	 ((somTD_EventComm_Consumer_somGetClass)(SOMObjectClassData.somGetClass))(((EventComm_Consumer *)((void *)this)))
	);
}


/* method: somGetClassName */
string   somGetClassName()
{
/*
 *  Return the name of the receiver's class.
 */
   return 	(
	 SOM_TestCls(this,_SOMCLASS_SOMObject),
	 ((somTD_EventComm_Consumer_somGetClassName)(SOMObjectClassData.somGetClassName))(((EventComm_Consumer *)((void *)this)))
	);
}


/* method: somGetSize */
long   somGetSize()
{
/*
 *  Return the size of the receiver.
 */
   return 	(
	 SOM_TestCls(this,_SOMCLASS_SOMObject),
	 ((somTD_EventComm_Consumer_somGetSize)(SOMObjectClassData.somGetSize))(((EventComm_Consumer *)((void *)this)))
	);
}


/* method: somIsA */
boolean   somIsA(SOMClass* aClassObj)
{
/*
 *  Returns 1 (true) if the receiver responds to methods
 *  introduced by <aClassObj>, and 0 (false) otherwise.
 */
   return 	(
	 SOM_TestCls(this,_SOMCLASS_SOMObject),
	 ((somTD_EventComm_Consumer_somIsA)(SOMObjectClassData.somIsA))(((EventComm_Consumer *)((void *)this)),aClassObj)
	);
}


/* method: somIsInstanceOf */
boolean   somIsInstanceOf(SOMClass* aClassObj)
{
/*
 *  Returns 1 (true) if the receiver is an instance of
 *  <aClassObj> and 0 (false) otherwise.
 */
   return 	(
	 SOM_TestCls(this,_SOMCLASS_SOMObject),
	 ((somTD_EventComm_Consumer_somIsInstanceOf)(SOMObjectClassData.somIsInstanceOf))(((EventComm_Consumer *)((void *)this)),aClassObj)
	);
}


/* method: somRespondsTo */
boolean   somRespondsTo(somId mId)
{
/*
 *  Returns 1 (true) if the indicated method can be invoked
 *  on the receiver and 0 (false) otherwise.
 */
   return 	(
	 SOM_TestCls(this,_SOMCLASS_SOMObject),
	 ((somTD_EventComm_Consumer_somRespondsTo)(SOMObjectClassData.somRespondsTo))(((EventComm_Consumer *)((void *)this)),mId)
	);
}


/* va_list method: somDispatch */

/*
 *  This method provides a generic, class-specific dispatch mechanism.
 *  It accepts as input <retValue> a pointer to the memory area to be
 *  loaded with the result of dispatching the method indicated by
 *  <methodId> using the arguments in <ap>. <ap> contains the object
 *  on which the method is to be invoked as the first argument.
 * 
 *  Default redispatch stubs invoke this method.
 */
/* the va_list invocation form */
boolean   SOMObject_somDispatch(somToken* retValue, 
		somId methodId, 
		va_list ap)
{   return 	(
	 SOM_TestCls(this,_SOMCLASS_SOMObject),
	 ((somTD_EventComm_Consumer_somDispatch)(SOMObjectClassData.somDispatch))(((EventComm_Consumer *)((void *)this)),retValue,methodId,ap)
	);
}

/* the varargs invocation form */
boolean   somDispatch(somToken* retValue, 
		somId methodId, 
		...)
{
/*
 *  This method provides a generic, class-specific dispatch mechanism.
 *  It accepts as input <retValue> a pointer to the memory area to be
 *  loaded with the result of dispatching the method indicated by
 *  <methodId> using the arguments in <ap>. <ap> contains the object
 *  on which the method is to be invoked as the first argument.
 * 
 *  Default redispatch stubs invoke this method.
 */
   va_list ap;
   va_start(ap, methodId);
   boolean __somResult = 
      	(
	 SOM_TestCls(this,_SOMCLASS_SOMObject),
	 ((somTD_EventComm_Consumer_somDispatch)(SOMObjectClassData.somDispatch))(((EventComm_Consumer *)((void *)this)),retValue,methodId,ap)
	);
   va_end(ap);
   return __somResult;
}


/* va_list method: somClassDispatch */

/*
 *  Like somDispatch, but method resolution for static methods is done
 *  according to the clsObj instance method table.
 */
/* the va_list invocation form */
boolean   SOMObject_somClassDispatch(SOMClass* clsObj, 
		somToken* retValue, 
		somId methodId, 
		va_list ap)
{   return 	(
	 SOM_TestCls(this,_SOMCLASS_SOMObject),
	 ((somTD_EventComm_Consumer_somClassDispatch)(SOMObjectClassData.somClassDispatch))(((EventComm_Consumer *)((void *)this)),clsObj,retValue,methodId,ap)
	);
}

/* the varargs invocation form */
boolean   somClassDispatch(SOMClass* clsObj, 
		somToken* retValue, 
		somId methodId, 
		...)
{
/*
 *  Like somDispatch, but method resolution for static methods is done
 *  according to the clsObj instance method table.
 */
   va_list ap;
   va_start(ap, methodId);
   boolean __somResult = 
      	(
	 SOM_TestCls(this,_SOMCLASS_SOMObject),
	 ((somTD_EventComm_Consumer_somClassDispatch)(SOMObjectClassData.somClassDispatch))(((EventComm_Consumer *)((void *)this)),clsObj,retValue,methodId,ap)
	);
   va_end(ap);
   return __somResult;
}


/* method: somCastObj */
boolean   somCastObj(SOMClass* castedCls)
{
/*
 *  Changes the behavior of the target object to that implemented
 *  by castedCls. This is possible when all concrete data in castedCls
 *  is also concrete in the true class of the target object.
 *  Returns true (1) on success, and false (0) otherwise.
 */
   return 	(
	 SOM_TestCls(this,_SOMCLASS_SOMObject),
	 ((somTD_EventComm_Consumer_somCastObj)(SOMObjectClassData.somCastObj))(((EventComm_Consumer *)((void *)this)),castedCls)
	);
}


/* method: somResetObj */
boolean   somResetObj()
{
/*
 *  reset an object to its true class. Returns true always.
 */
   return 	(
	 SOM_TestCls(this,_SOMCLASS_SOMObject),
	 ((somTD_EventComm_Consumer_somResetObj)(SOMObjectClassData.somResetObj))(((EventComm_Consumer *)((void *)this)))
	);
}


/* method: somPrintSelf */
EventComm_Consumer*  somPrintSelf()
{
/*
 *  Uses <SOMOutCharRoutine> to write a brief string with identifying
 *  information about this object.  The default implementation just gives
 *  the object's class name and its address in memory.
 *  <self> is returned.
 */
   return 	(
	 SOM_TestCls(this,_SOMCLASS_SOMObject),
	 ((somTD_EventComm_Consumer_somPrintSelf)(SOMObjectClassData.somPrintSelf))(((EventComm_Consumer *)((void *)this)))
	);
}


/* method: somDumpSelf */
void   somDumpSelf(long level)
{
/*
 *  Uses <SOMOutCharRoutine> to write a detailed description of this object
 *  and its current state.
 * 
 *  <level> indicates the nesting level for describing compound objects
 *  it must be greater than or equal to zero.  All lines in the
 *  description will be preceeded by <2*level> spaces.
 * 
 *  This routine only actually writes the data that concerns the object
 *  as a whole, such as class, and uses <somDumpSelfInt> to describe
 *  the object's current state.  This approach allows readable
 *  descriptions of compound objects to be constructed.
 * 
 *  Generally it is not necessary to override this method, if it is
 *  overriden it generally must be completely replaced.
 */
   	(
	 SOM_TestCls(this,_SOMCLASS_SOMObject),
	 ((somTD_EventComm_Consumer_somDumpSelf)(SOMObjectClassData.somDumpSelf))(((EventComm_Consumer *)((void *)this)),level)
	);
}


/* method: somDumpSelfInt */
void   somDumpSelfInt(long level)
{
/*
 *  Uses <SOMOutCharRoutine> to write in the current state of this object.
 *  Generally this method will need to be overridden.  When overriding
 *  it, begin by calling the parent class form of this method and then
 *  write in a description of your class's instance data. This will
 *  result in a description of all the object's instance data going
 *  from its root ancestor class to its specific class.
 */
   	(
	 SOM_TestCls(this,_SOMCLASS_SOMObject),
	 ((somTD_EventComm_Consumer_somDumpSelfInt)(SOMObjectClassData.somDumpSelfInt))(((EventComm_Consumer *)((void *)this)),level)
	);
}



};   /* EventComm_Consumer */



#endif       /* SOM_EventComm_Consumer_xh */

#ifndef SOM_EventComm_Supplier_xh
#define SOM_EventComm_Supplier_xh


#define EventComm_Supplier_MajorVersion 1
#define EventComm_Supplier_MinorVersion 1
class EventComm_Supplier;

/* Parents */
#ifndef SOM_EventComm_EventConnection_xh
#ifdef SOMLOCALINCLUDES
#include "eventcom.xh"
#else
#include <eventcom.xh>
#endif
#endif

/* Useful C++ SOM defs */
#include <somcls.xh>
#include <somcm.xh>

#ifndef EventComm_Supplier_API
#define EventComm_Supplier_API
/*
 * -- The Class API
 */

/*
 * Start of bindings for IDL types
 */


/*
 * End of bindings for IDL types.
 */

/*
 * A function to create the EventComm_Supplier class object...
 */
SOMEXTERN SOM_IMPORTEXPORT_event_eventcom SOMClass * SOMLINK EventComm_SupplierNewClass(
		integer4 majorVersion,
		integer4 minorVersion);


/*
 * The API 2 ClassData Structures...
 */
SOMEXTERN struct EventComm_SupplierClassDataStructure {
	SOMClass *classObject;
	somMToken try_pull;
	somMToken _get_ev_con;
	somMToken _set_ev_con;
} SOMDLINK SOM_IMPORTEXPORT_event_eventcom EventComm_SupplierClassData;
SOMEXTERN struct EventComm_SupplierCClassDataStructure {
	som3ClassDetailsPtr    parentMtab;
	somDToken              instanceDataToken;
} SOMDLINK SOM_IMPORTEXPORT_event_eventcom EventComm_SupplierCClassData;


/*
 * Class Object and Method Token Macros
 */
#define _SOMCLASS_EventComm_Supplier (EventComm_SupplierClassData.classObject)
#ifndef SOMGD_EventComm_Supplier
    #if (defined(_EventComm_Supplier) || defined(__EventComm_Supplier))
        #undef _EventComm_Supplier
        #undef __EventComm_Supplier
        #define SOMGD_EventComm_Supplier 1
    #else
        #define _EventComm_Supplier _SOMCLASS_EventComm_Supplier
    #endif /* _EventComm_Supplier */
#endif /* SOMGD_EventComm_Supplier */
#define EventComm_Supplier_classObj _SOMCLASS_EventComm_Supplier
#define _SOMMTOKEN_EventComm_Supplier(method) ((somMToken)EventComm_SupplierClassData.method)

/*
 * -- Typedefs for EventComm_Supplier Method Procedures
 */
SOMEXTERN {
typedef EventComm_EventConnection*   SOMLINK somTP_EventComm_Supplier__get_ev_con(EventComm_Supplier *somSelf, Environment *ev);
typedef somTP_EventComm_Supplier__get_ev_con *somTD_EventComm_Supplier__get_ev_con;
typedef void   SOMLINK somTP_EventComm_Supplier__set_ev_con(EventComm_Supplier *somSelf, Environment *ev, 
		EventComm_EventConnection* ev_con);
typedef somTP_EventComm_Supplier__set_ev_con *somTD_EventComm_Supplier__set_ev_con;
typedef boolean   SOMLINK somTP_EventComm_Supplier_try_pull(EventComm_Supplier *somSelf, Environment *ev, 
		any* event_data);
typedef somTP_EventComm_Supplier_try_pull *somTD_EventComm_Supplier_try_pull;

/*
 * -- Typedefs for Reintroduced Wrapper Methods
 */
typedef void   SOMLINK somTP_EventComm_Supplier_disconnect(EventComm_Supplier *somSelf, Environment *ev);
typedef somTP_EventComm_Supplier_disconnect *somTD_EventComm_Supplier_disconnect;
typedef void   SOMLINK somTP_EventComm_Supplier_somDefaultInit(EventComm_Supplier *somSelf, 
		som3InitCtrl* ctrl);
typedef somTP_EventComm_Supplier_somDefaultInit *somTD_EventComm_Supplier_somDefaultInit;
typedef void   SOMLINK somTP_EventComm_Supplier_somDestruct(EventComm_Supplier *somSelf, 
		octet doFree, 
		som3DestructCtrl* ctrl);
typedef somTP_EventComm_Supplier_somDestruct *somTD_EventComm_Supplier_somDestruct;
typedef void   SOMLINK somTP_EventComm_Supplier_somDefaultCopyInit(EventComm_Supplier *somSelf, 
		som3InitCtrl* ctrl, 
		SOMObject* fromObj);
typedef somTP_EventComm_Supplier_somDefaultCopyInit *somTD_EventComm_Supplier_somDefaultCopyInit;
typedef EventComm_Supplier*   SOMLINK somTP_EventComm_Supplier_somDefaultAssign(EventComm_Supplier *somSelf, 
		som3AssignCtrl* ctrl, 
		SOMObject* fromObj);
typedef somTP_EventComm_Supplier_somDefaultAssign *somTD_EventComm_Supplier_somDefaultAssign;
typedef void   SOMLINK somTP_EventComm_Supplier_somDefaultConstCopyInit(EventComm_Supplier *somSelf, 
		som3InitCtrl* ctrl, 
		SOMObject* fromObj);
typedef somTP_EventComm_Supplier_somDefaultConstCopyInit *somTD_EventComm_Supplier_somDefaultConstCopyInit;
typedef void   SOMLINK somTP_EventComm_Supplier_somDefaultVCopyInit(EventComm_Supplier *somSelf, 
		som3InitCtrl* ctrl, 
		SOMObject* fromObj);
typedef somTP_EventComm_Supplier_somDefaultVCopyInit *somTD_EventComm_Supplier_somDefaultVCopyInit;
typedef void   SOMLINK somTP_EventComm_Supplier_somDefaultConstVCopyInit(EventComm_Supplier *somSelf, 
		som3InitCtrl* ctrl, 
		SOMObject* fromObj);
typedef somTP_EventComm_Supplier_somDefaultConstVCopyInit *somTD_EventComm_Supplier_somDefaultConstVCopyInit;
typedef EventComm_Supplier*   SOMLINK somTP_EventComm_Supplier_somDefaultConstAssign(EventComm_Supplier *somSelf, 
		som3AssignCtrl* ctrl, 
		SOMObject* fromObj);
typedef somTP_EventComm_Supplier_somDefaultConstAssign *somTD_EventComm_Supplier_somDefaultConstAssign;
typedef EventComm_Supplier*   SOMLINK somTP_EventComm_Supplier_somDefaultVAssign(EventComm_Supplier *somSelf, 
		som3AssignCtrl* ctrl, 
		SOMObject* fromObj);
typedef somTP_EventComm_Supplier_somDefaultVAssign *somTD_EventComm_Supplier_somDefaultVAssign;
typedef EventComm_Supplier*   SOMLINK somTP_EventComm_Supplier_somDefaultConstVAssign(EventComm_Supplier *somSelf, 
		som3AssignCtrl* ctrl, 
		SOMObject* fromObj);
typedef somTP_EventComm_Supplier_somDefaultConstVAssign *somTD_EventComm_Supplier_somDefaultConstVAssign;
typedef void   SOMLINK somTP_EventComm_Supplier_somInit(EventComm_Supplier *somSelf);
typedef somTP_EventComm_Supplier_somInit *somTD_EventComm_Supplier_somInit;
typedef void   SOMLINK somTP_EventComm_Supplier_somUninit(EventComm_Supplier *somSelf);
typedef somTP_EventComm_Supplier_somUninit *somTD_EventComm_Supplier_somUninit;
typedef void   SOMLINK somTP_EventComm_Supplier_somFree(EventComm_Supplier *somSelf);
typedef somTP_EventComm_Supplier_somFree *somTD_EventComm_Supplier_somFree;
typedef SOMClass*   SOMLINK somTP_EventComm_Supplier_somGetClass(EventComm_Supplier *somSelf);
typedef somTP_EventComm_Supplier_somGetClass *somTD_EventComm_Supplier_somGetClass;
typedef string   SOMLINK somTP_EventComm_Supplier_somGetClassName(EventComm_Supplier *somSelf);
typedef somTP_EventComm_Supplier_somGetClassName *somTD_EventComm_Supplier_somGetClassName;
typedef long   SOMLINK somTP_EventComm_Supplier_somGetSize(EventComm_Supplier *somSelf);
typedef somTP_EventComm_Supplier_somGetSize *somTD_EventComm_Supplier_somGetSize;
typedef boolean   SOMLINK somTP_EventComm_Supplier_somIsA(EventComm_Supplier *somSelf, 
		SOMClass* aClassObj);
typedef somTP_EventComm_Supplier_somIsA *somTD_EventComm_Supplier_somIsA;
typedef boolean   SOMLINK somTP_EventComm_Supplier_somIsInstanceOf(EventComm_Supplier *somSelf, 
		SOMClass* aClassObj);
typedef somTP_EventComm_Supplier_somIsInstanceOf *somTD_EventComm_Supplier_somIsInstanceOf;
typedef boolean   SOMLINK somTP_EventComm_Supplier_somRespondsTo(EventComm_Supplier *somSelf, 
		somId mId);
typedef somTP_EventComm_Supplier_somRespondsTo *somTD_EventComm_Supplier_somRespondsTo;
typedef boolean   SOMLINK somTP_EventComm_Supplier_somDispatch(EventComm_Supplier *somSelf, 
		somToken* retValue, 
		somId methodId, 
		va_list ap);
typedef somTP_EventComm_Supplier_somDispatch *somTD_EventComm_Supplier_somDispatch;
typedef boolean   SOMLINK somTP_EventComm_Supplier_somClassDispatch(EventComm_Supplier *somSelf, 
		SOMClass* clsObj, 
		somToken* retValue, 
		somId methodId, 
		va_list ap);
typedef somTP_EventComm_Supplier_somClassDispatch *somTD_EventComm_Supplier_somClassDispatch;
typedef boolean   SOMLINK somTP_EventComm_Supplier_somCastObj(EventComm_Supplier *somSelf, 
		SOMClass* castedCls);
typedef somTP_EventComm_Supplier_somCastObj *somTD_EventComm_Supplier_somCastObj;
typedef boolean   SOMLINK somTP_EventComm_Supplier_somResetObj(EventComm_Supplier *somSelf);
typedef somTP_EventComm_Supplier_somResetObj *somTD_EventComm_Supplier_somResetObj;
typedef EventComm_Supplier*   SOMLINK somTP_EventComm_Supplier_somPrintSelf(EventComm_Supplier *somSelf);
typedef somTP_EventComm_Supplier_somPrintSelf *somTD_EventComm_Supplier_somPrintSelf;
typedef void   SOMLINK somTP_EventComm_Supplier_somDumpSelf(EventComm_Supplier *somSelf, 
		long level);
typedef somTP_EventComm_Supplier_somDumpSelf *somTD_EventComm_Supplier_somDumpSelf;
typedef void   SOMLINK somTP_EventComm_Supplier_somDumpSelfInt(EventComm_Supplier *somSelf, 
		long level);
typedef somTP_EventComm_Supplier_somDumpSelfInt *somTD_EventComm_Supplier_somDumpSelfInt;
}

#endif /* EventComm_Supplier_API */


/*
 * -- The C++ Wrapper Class for EventComm_Supplier
 */
class EventComm_Supplier : public EventComm_EventConnection
{
public:

// EventComm_Supplier::new creates the class object if necessary, and then uses
// somNewNoInit to allocate memory and create the object.
// Initialization is in ctors.
void *operator new(size_t)
{
   if (!_EventComm_Supplier) EventComm_SupplierNewClass(EventComm_Supplier_MajorVersion,EventComm_Supplier_MinorVersion);
   return (void*)
   (((somTD_SOMClass_somNewNoInit)(SOMClassClassData.somNewNoInit))
         ((SOMClass *)((void*)_EventComm_Supplier)));
}

// EventComm_Supplier::delete uses somFree.
void operator delete(void * obj)
{
   if (obj && *(void**)obj)
      ((SOMObject*)obj)->somFree();
}

EventComm_Supplier& operator=(EventComm_Supplier& fromObj)
{
   this->somDefaultAssign(0,(SOMObject*)((void*)&fromObj));
   return *this;
}

EventComm_Supplier()
{
   if (*(void**)this != (EventComm_SupplierCClassData.parentMtab)->mtab)
      return;
   ((SOMObject*)((void*)this))->somDefaultInit(0);
}

EventComm_Supplier(EventComm_Supplier* fromObj)
{
   if (*(void**)this != (EventComm_SupplierCClassData.parentMtab)->mtab)
      return;
   ((SOMObject*)((void*)this))->somDefaultCopyInit(0,((SOMObject*)((void*)fromObj)));
}


/* method: _get_ev_con */
EventComm_EventConnection*   _get_ev_con(Environment *ev)
{
/*
 * Method from the IDL attribute statement:
 * "attribute EventComm_EventConnection* ev_con"
 */
   return 	(
	 SOM_TestCls(this,_SOMCLASS_EventComm_Supplier),
	 ((somTD_EventComm_Supplier__get_ev_con)(EventComm_SupplierClassData._get_ev_con))(((EventComm_Supplier *)((void *)this)), ev)
	);
}


/* method: _set_ev_con */
void   _set_ev_con(Environment *ev, 
		EventComm_EventConnection* ev_con)
{
/*
 * Method from the IDL attribute statement:
 * "attribute EventComm_EventConnection* ev_con"
 */
   	(
	 SOM_TestCls(this,_SOMCLASS_EventComm_Supplier),
	 ((somTD_EventComm_Supplier__set_ev_con)(EventComm_SupplierClassData._set_ev_con))(((EventComm_Supplier *)((void *)this)), ev,ev_con)
	);
}


/* method: try_pull */
boolean   try_pull(Environment *ev, 
		any* event_data)
{
   return 	(
	 SOM_TestCls(this,_SOMCLASS_EventComm_Supplier),
	 ((somTD_EventComm_Supplier_try_pull)(EventComm_SupplierClassData.try_pull))(((EventComm_Supplier *)((void *)this)), ev,event_data)
	);
}


/*
 * Reintroduce inherited methods
 */

/* method: disconnect */
void   disconnect(Environment *ev)
{
   	(
	 SOM_TestCls(this,_SOMCLASS_EventComm_EventConnection),
	 ((somTD_EventComm_Supplier_disconnect)(EventComm_EventConnectionClassData.disconnect))(((EventComm_Supplier *)((void *)this)), ev)
	);
}


/* initializer method: somDefaultInit */
void   somDefaultInit(som3InitCtrl* ctrl)
{
/*
 *  A default initializer for a SOM object. Passing a null ctrl
 *  indicates to the receiver that its class is the class of the
 *  object being initialized, whereby the initializer will determine
 *  an appropriate control structure.
 */
   	(
	 SOM_TestCls(this,_SOMCLASS_SOMObject),
	 ((somTD_EventComm_Supplier_somDefaultInit)(SOMObjectClassData.somDefaultInit))(((EventComm_Supplier *)((void *)this)),ctrl)
	);
}


/* method: somDestruct */
void   somDestruct(octet doFree, 
		som3DestructCtrl* ctrl)
{
/*
 *  The default destructor for a SOM object. A nonzero <doFree>
 *  indicates that the object storage should be freed by the
 *  object's class (via somDeallocate) after uninitialization.
 *  As with somDefaultInit, a null ctrl can be passed.
 */
   	(
	 SOM_TestCls(this,_SOMCLASS_SOMObject),
	 ((somTD_EventComm_Supplier_somDestruct)(SOMObjectClassData.somDestruct))(((EventComm_Supplier *)((void *)this)),doFree,ctrl)
	);
}


/* initializer method: somDefaultCopyInit */
void   somDefaultCopyInit(som3InitCtrl* ctrl, 
		SOMObject* fromObj)
{
/*
 *  A default copy constructor. Use this to make copies of objects for
 *  calling methods with "by-value" argument semantics.
 */
   	(
	 SOM_TestCls(this,_SOMCLASS_SOMObject),
	 ((somTD_EventComm_Supplier_somDefaultCopyInit)(SOMObjectClassData.somDefaultCopyInit))(((EventComm_Supplier *)((void *)this)),ctrl,fromObj)
	);
}


/* method: somDefaultAssign */
EventComm_Supplier*  somDefaultAssign(som3AssignCtrl* ctrl, 
		SOMObject* fromObj)
{
/*
 *  A default assignment operator. Use this to "assign" the state of one
 *  object to another.
 */
   return 	(
	 SOM_TestCls(this,_SOMCLASS_SOMObject),
	 ((somTD_EventComm_Supplier_somDefaultAssign)(SOMObjectClassData.somDefaultAssign))(((EventComm_Supplier *)((void *)this)),ctrl,fromObj)
	);
}


/* initializer method: somDefaultConstCopyInit */
void   somDefaultConstCopyInit(som3InitCtrl* ctrl, 
		SOMObject* fromObj)
{
/*
 *  A default copy constructor that uses a const fromObj.
 */
   	(
	 SOM_TestCls(this,_SOMCLASS_SOMObject),
	 ((somTD_EventComm_Supplier_somDefaultConstCopyInit)(SOMObjectClassData.somDefaultConstCopyInit))(((EventComm_Supplier *)((void *)this)),ctrl,fromObj)
	);
}


/* initializer method: somDefaultVCopyInit */
void   somDefaultVCopyInit(som3InitCtrl* ctrl, 
		SOMObject* fromObj)
{
/*
 *  A default copy constructor that uses a volatile fromObj.
 */
   	(
	 SOM_TestCls(this,_SOMCLASS_SOMObject),
	 ((somTD_EventComm_Supplier_somDefaultVCopyInit)(SOMObjectClassData.somDefaultVCopyInit))(((EventComm_Supplier *)((void *)this)),ctrl,fromObj)
	);
}


/* initializer method: somDefaultConstVCopyInit */
void   somDefaultConstVCopyInit(som3InitCtrl* ctrl, 
		SOMObject* fromObj)
{
/*
 *  A default copy constructor that uses a const volatile fromObj.
 */
   	(
	 SOM_TestCls(this,_SOMCLASS_SOMObject),
	 ((somTD_EventComm_Supplier_somDefaultConstVCopyInit)(SOMObjectClassData.somDefaultConstVCopyInit))(((EventComm_Supplier *)((void *)this)),ctrl,fromObj)
	);
}


/* method: somDefaultConstAssign */
EventComm_Supplier*  somDefaultConstAssign(som3AssignCtrl* ctrl, 
		SOMObject* fromObj)
{
/*
 *  A default assignment operator that uses a const fromObj.
 */
   return 	(
	 SOM_TestCls(this,_SOMCLASS_SOMObject),
	 ((somTD_EventComm_Supplier_somDefaultConstAssign)(SOMObjectClassData.somDefaultConstAssign))(((EventComm_Supplier *)((void *)this)),ctrl,fromObj)
	);
}


/* method: somDefaultVAssign */
EventComm_Supplier*  somDefaultVAssign(som3AssignCtrl* ctrl, 
		SOMObject* fromObj)
{
/*
 *  A default assignment operator that uses a volatile fromObj.
 */
   return 	(
	 SOM_TestCls(this,_SOMCLASS_SOMObject),
	 ((somTD_EventComm_Supplier_somDefaultVAssign)(SOMObjectClassData.somDefaultVAssign))(((EventComm_Supplier *)((void *)this)),ctrl,fromObj)
	);
}


/* method: somDefaultConstVAssign */
EventComm_Supplier*  somDefaultConstVAssign(som3AssignCtrl* ctrl, 
		SOMObject* fromObj)
{
/*
 *  A default assignment operator that uses a const volatile fromObj.
 */
   return 	(
	 SOM_TestCls(this,_SOMCLASS_SOMObject),
	 ((somTD_EventComm_Supplier_somDefaultConstVAssign)(SOMObjectClassData.somDefaultConstVAssign))(((EventComm_Supplier *)((void *)this)),ctrl,fromObj)
	);
}


/* method: somInit */
void   somInit()
{
/*
 *  Obsolete but still supported. Override somDefaultInit instead of somInit.
 */
   	(
	 SOM_TestCls(this,_SOMCLASS_SOMObject),
	 ((somTD_EventComm_Supplier_somInit)(SOMObjectClassData.somInit))(((EventComm_Supplier *)((void *)this)))
	);
}


/* method: somUninit */
void   somUninit()
{
/*
 *  Obsolete but still supported. Override somDestruct instead of somUninit.
 */
   	(
	 SOM_TestCls(this,_SOMCLASS_SOMObject),
	 ((somTD_EventComm_Supplier_somUninit)(SOMObjectClassData.somUninit))(((EventComm_Supplier *)((void *)this)))
	);
}


/* method: somFree */
void   somFree()
{
/*
 *  The default implementation just calls somDestruct.
 */
   	(
	 SOM_TestCls(this,_SOMCLASS_SOMObject),
	 ((somTD_EventComm_Supplier_somFree)(SOMObjectClassData.somFree))(((EventComm_Supplier *)((void *)this)))
	);
}


/* method: somGetClass */
SOMClass*   somGetClass()
{
/*
 *  Return the receiver's class.
 */
   return 	(
	 SOM_TestCls(this,_SOMCLASS_SOMObject),
	 ((somTD_EventComm_Supplier_somGetClass)(SOMObjectClassData.somGetClass))(((EventComm_Supplier *)((void *)this)))
	);
}


/* method: somGetClassName */
string   somGetClassName()
{
/*
 *  Return the name of the receiver's class.
 */
   return 	(
	 SOM_TestCls(this,_SOMCLASS_SOMObject),
	 ((somTD_EventComm_Supplier_somGetClassName)(SOMObjectClassData.somGetClassName))(((EventComm_Supplier *)((void *)this)))
	);
}


/* method: somGetSize */
long   somGetSize()
{
/*
 *  Return the size of the receiver.
 */
   return 	(
	 SOM_TestCls(this,_SOMCLASS_SOMObject),
	 ((somTD_EventComm_Supplier_somGetSize)(SOMObjectClassData.somGetSize))(((EventComm_Supplier *)((void *)this)))
	);
}


/* method: somIsA */
boolean   somIsA(SOMClass* aClassObj)
{
/*
 *  Returns 1 (true) if the receiver responds to methods
 *  introduced by <aClassObj>, and 0 (false) otherwise.
 */
   return 	(
	 SOM_TestCls(this,_SOMCLASS_SOMObject),
	 ((somTD_EventComm_Supplier_somIsA)(SOMObjectClassData.somIsA))(((EventComm_Supplier *)((void *)this)),aClassObj)
	);
}


/* method: somIsInstanceOf */
boolean   somIsInstanceOf(SOMClass* aClassObj)
{
/*
 *  Returns 1 (true) if the receiver is an instance of
 *  <aClassObj> and 0 (false) otherwise.
 */
   return 	(
	 SOM_TestCls(this,_SOMCLASS_SOMObject),
	 ((somTD_EventComm_Supplier_somIsInstanceOf)(SOMObjectClassData.somIsInstanceOf))(((EventComm_Supplier *)((void *)this)),aClassObj)
	);
}


/* method: somRespondsTo */
boolean   somRespondsTo(somId mId)
{
/*
 *  Returns 1 (true) if the indicated method can be invoked
 *  on the receiver and 0 (false) otherwise.
 */
   return 	(
	 SOM_TestCls(this,_SOMCLASS_SOMObject),
	 ((somTD_EventComm_Supplier_somRespondsTo)(SOMObjectClassData.somRespondsTo))(((EventComm_Supplier *)((void *)this)),mId)
	);
}


/* va_list method: somDispatch */

/*
 *  This method provides a generic, class-specific dispatch mechanism.
 *  It accepts as input <retValue> a pointer to the memory area to be
 *  loaded with the result of dispatching the method indicated by
 *  <methodId> using the arguments in <ap>. <ap> contains the object
 *  on which the method is to be invoked as the first argument.
 * 
 *  Default redispatch stubs invoke this method.
 */
/* the va_list invocation form */
boolean   SOMObject_somDispatch(somToken* retValue, 
		somId methodId, 
		va_list ap)
{   return 	(
	 SOM_TestCls(this,_SOMCLASS_SOMObject),
	 ((somTD_EventComm_Supplier_somDispatch)(SOMObjectClassData.somDispatch))(((EventComm_Supplier *)((void *)this)),retValue,methodId,ap)
	);
}

/* the varargs invocation form */
boolean   somDispatch(somToken* retValue, 
		somId methodId, 
		...)
{
/*
 *  This method provides a generic, class-specific dispatch mechanism.
 *  It accepts as input <retValue> a pointer to the memory area to be
 *  loaded with the result of dispatching the method indicated by
 *  <methodId> using the arguments in <ap>. <ap> contains the object
 *  on which the method is to be invoked as the first argument.
 * 
 *  Default redispatch stubs invoke this method.
 */
   va_list ap;
   va_start(ap, methodId);
   boolean __somResult = 
      	(
	 SOM_TestCls(this,_SOMCLASS_SOMObject),
	 ((somTD_EventComm_Supplier_somDispatch)(SOMObjectClassData.somDispatch))(((EventComm_Supplier *)((void *)this)),retValue,methodId,ap)
	);
   va_end(ap);
   return __somResult;
}


/* va_list method: somClassDispatch */

/*
 *  Like somDispatch, but method resolution for static methods is done
 *  according to the clsObj instance method table.
 */
/* the va_list invocation form */
boolean   SOMObject_somClassDispatch(SOMClass* clsObj, 
		somToken* retValue, 
		somId methodId, 
		va_list ap)
{   return 	(
	 SOM_TestCls(this,_SOMCLASS_SOMObject),
	 ((somTD_EventComm_Supplier_somClassDispatch)(SOMObjectClassData.somClassDispatch))(((EventComm_Supplier *)((void *)this)),clsObj,retValue,methodId,ap)
	);
}

/* the varargs invocation form */
boolean   somClassDispatch(SOMClass* clsObj, 
		somToken* retValue, 
		somId methodId, 
		...)
{
/*
 *  Like somDispatch, but method resolution for static methods is done
 *  according to the clsObj instance method table.
 */
   va_list ap;
   va_start(ap, methodId);
   boolean __somResult = 
      	(
	 SOM_TestCls(this,_SOMCLASS_SOMObject),
	 ((somTD_EventComm_Supplier_somClassDispatch)(SOMObjectClassData.somClassDispatch))(((EventComm_Supplier *)((void *)this)),clsObj,retValue,methodId,ap)
	);
   va_end(ap);
   return __somResult;
}


/* method: somCastObj */
boolean   somCastObj(SOMClass* castedCls)
{
/*
 *  Changes the behavior of the target object to that implemented
 *  by castedCls. This is possible when all concrete data in castedCls
 *  is also concrete in the true class of the target object.
 *  Returns true (1) on success, and false (0) otherwise.
 */
   return 	(
	 SOM_TestCls(this,_SOMCLASS_SOMObject),
	 ((somTD_EventComm_Supplier_somCastObj)(SOMObjectClassData.somCastObj))(((EventComm_Supplier *)((void *)this)),castedCls)
	);
}


/* method: somResetObj */
boolean   somResetObj()
{
/*
 *  reset an object to its true class. Returns true always.
 */
   return 	(
	 SOM_TestCls(this,_SOMCLASS_SOMObject),
	 ((somTD_EventComm_Supplier_somResetObj)(SOMObjectClassData.somResetObj))(((EventComm_Supplier *)((void *)this)))
	);
}


/* method: somPrintSelf */
EventComm_Supplier*  somPrintSelf()
{
/*
 *  Uses <SOMOutCharRoutine> to write a brief string with identifying
 *  information about this object.  The default implementation just gives
 *  the object's class name and its address in memory.
 *  <self> is returned.
 */
   return 	(
	 SOM_TestCls(this,_SOMCLASS_SOMObject),
	 ((somTD_EventComm_Supplier_somPrintSelf)(SOMObjectClassData.somPrintSelf))(((EventComm_Supplier *)((void *)this)))
	);
}


/* method: somDumpSelf */
void   somDumpSelf(long level)
{
/*
 *  Uses <SOMOutCharRoutine> to write a detailed description of this object
 *  and its current state.
 * 
 *  <level> indicates the nesting level for describing compound objects
 *  it must be greater than or equal to zero.  All lines in the
 *  description will be preceeded by <2*level> spaces.
 * 
 *  This routine only actually writes the data that concerns the object
 *  as a whole, such as class, and uses <somDumpSelfInt> to describe
 *  the object's current state.  This approach allows readable
 *  descriptions of compound objects to be constructed.
 * 
 *  Generally it is not necessary to override this method, if it is
 *  overriden it generally must be completely replaced.
 */
   	(
	 SOM_TestCls(this,_SOMCLASS_SOMObject),
	 ((somTD_EventComm_Supplier_somDumpSelf)(SOMObjectClassData.somDumpSelf))(((EventComm_Supplier *)((void *)this)),level)
	);
}


/* method: somDumpSelfInt */
void   somDumpSelfInt(long level)
{
/*
 *  Uses <SOMOutCharRoutine> to write in the current state of this object.
 *  Generally this method will need to be overridden.  When overriding
 *  it, begin by calling the parent class form of this method and then
 *  write in a description of your class's instance data. This will
 *  result in a description of all the object's instance data going
 *  from its root ancestor class to its specific class.
 */
   	(
	 SOM_TestCls(this,_SOMCLASS_SOMObject),
	 ((somTD_EventComm_Supplier_somDumpSelfInt)(SOMObjectClassData.somDumpSelfInt))(((EventComm_Supplier *)((void *)this)),level)
	);
}



};   /* EventComm_Supplier */



#endif       /* SOM_EventComm_Supplier_xh */
