datacls.xh

/*
 * This file was generated by the SOM Compiler.
 * FileName: datacls.xh.
 * Generated using:
 *     SOM Precompiler somipc: 2.29.1.17
 *     SOM Emitter emitxh: 2.47
 */

#ifndef SOM_KeyObject_xh
#define SOM_KeyObject_xh

class KeyObject;

#define KeyObject_MajorVersion 2
#define KeyObject_MinorVersion 1

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

/* C++ parent defs */
#ifndef SOM_somf_TCollectibleLong_xh
#include <tclong.xh>
#endif

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

/*
 * Start of bindings for IDL types
 */

class SOMClass;
class SOMObject;
class THAssoc;
class somf_TAssoc;
class WPObject;
class WPFolder;
class WPImageFile;
class M_WPObject;
class M_RMDeviceCollection;

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

/*
 * Passthru lines: File: "C.xh", "after"
 */

#include <thash.xh>
#include <tclong.xh>
#include <thashitr.xh>


/* A procedure to create the KeyObject Class */
SOMEXTERN SOMClass * SOMLINK KeyObjectNewClass(
		integer4 majorVersion,
		integer4 minorVersion);

/* The API to the KeyObject class object, and the methods it introduces. */
SOMEXTERN struct KeyObjectClassDataStructure {
	SOMClass *classObject;
} SOMDLINK KeyObjectClassData;
#define _KeyObject KeyObjectClassData.classObject

/* The API to parentMtabs for KeyObject, and the instance data it introduces. */
SOMEXTERN struct KeyObjectCClassDataStructure {
	somMethodTabs parentMtab;
	somDToken              instanceDataToken;
} SOMDLINK KeyObjectCClassData;

/*
 * -- Typedefs for KeyObject Method Procedures
 */
SOMEXTERN {

/*
 * -- Typedefs for Reintroduced Wrapper Methods
 */
typedef somf_TCollectibleLong*   SOMLINK somTP_KeyObject_somfTCollectibleLongInit(KeyObject *somSelf, Environment *ev, 
		long v);
typedef somTP_KeyObject_somfTCollectibleLongInit *somTD_KeyObject_somfTCollectibleLongInit;
typedef long   SOMLINK somTP_KeyObject_somfGetValue(KeyObject *somSelf, Environment *ev);
typedef somTP_KeyObject_somfGetValue *somTD_KeyObject_somfGetValue;
typedef void   SOMLINK somTP_KeyObject_somfSetValue(KeyObject *somSelf, Environment *ev, 
		long v);
typedef somTP_KeyObject_somfSetValue *somTD_KeyObject_somfSetValue;
typedef void   SOMLINK somTP_KeyObject_somInit(KeyObject *somSelf);
typedef somTP_KeyObject_somInit *somTD_KeyObject_somInit;
typedef boolean   SOMLINK somTP_KeyObject_somfIsEqual(KeyObject *somSelf, Environment *ev, 
		somf_MCollectible* obj);
typedef somTP_KeyObject_somfIsEqual *somTD_KeyObject_somfIsEqual;
typedef long   SOMLINK somTP_KeyObject_somfHash(KeyObject *somSelf, Environment *ev);
typedef somTP_KeyObject_somfHash *somTD_KeyObject_somfHash;
typedef somf_MCollectible*   SOMLINK somTP_KeyObject_somfClone(KeyObject *somSelf, Environment *ev);
typedef somTP_KeyObject_somfClone *somTD_KeyObject_somfClone;
typedef somf_MCollectible*   SOMLINK somTP_KeyObject_somfClonePointer(KeyObject *somSelf, Environment *ev, 
		somf_MCollectible* clonee);
typedef somTP_KeyObject_somfClonePointer *somTD_KeyObject_somfClonePointer;
typedef boolean   SOMLINK somTP_KeyObject_somfIsSame(KeyObject *somSelf, Environment *ev, 
		somf_MCollectible* obj);
typedef somTP_KeyObject_somfIsSame *somTD_KeyObject_somfIsSame;
typedef boolean   SOMLINK somTP_KeyObject_somfIsNotEqual(KeyObject *somSelf, Environment *ev, 
		somf_MCollectible* obj);
typedef somTP_KeyObject_somfIsNotEqual *somTD_KeyObject_somfIsNotEqual;
typedef void   SOMLINK somTP_KeyObject_somDefaultInit(KeyObject *somSelf, 
		som3InitCtrl* ctrl);
typedef somTP_KeyObject_somDefaultInit *somTD_KeyObject_somDefaultInit;
typedef void   SOMLINK somTP_KeyObject_somDestruct(KeyObject *somSelf, 
		octet doFree, 
		som3DestructCtrl* ctrl);
typedef somTP_KeyObject_somDestruct *somTD_KeyObject_somDestruct;
typedef void   SOMLINK somTP_KeyObject_somDefaultCopyInit(KeyObject *somSelf, 
		som3InitCtrl* ctrl, 
		SOMObject* fromObj);
typedef somTP_KeyObject_somDefaultCopyInit *somTD_KeyObject_somDefaultCopyInit;
typedef KeyObject*   SOMLINK somTP_KeyObject_somDefaultAssign(KeyObject *somSelf, 
		som3AssignCtrl* ctrl, 
		SOMObject* fromObj);
typedef somTP_KeyObject_somDefaultAssign *somTD_KeyObject_somDefaultAssign;
typedef void   SOMLINK somTP_KeyObject_somDefaultConstCopyInit(KeyObject *somSelf, 
		som3InitCtrl* ctrl, 
		SOMObject* fromObj);
typedef somTP_KeyObject_somDefaultConstCopyInit *somTD_KeyObject_somDefaultConstCopyInit;
typedef void   SOMLINK somTP_KeyObject_somDefaultVCopyInit(KeyObject *somSelf, 
		som3InitCtrl* ctrl, 
		SOMObject* fromObj);
typedef somTP_KeyObject_somDefaultVCopyInit *somTD_KeyObject_somDefaultVCopyInit;
typedef void   SOMLINK somTP_KeyObject_somDefaultConstVCopyInit(KeyObject *somSelf, 
		som3InitCtrl* ctrl, 
		SOMObject* fromObj);
typedef somTP_KeyObject_somDefaultConstVCopyInit *somTD_KeyObject_somDefaultConstVCopyInit;
typedef KeyObject*   SOMLINK somTP_KeyObject_somDefaultConstAssign(KeyObject *somSelf, 
		som3AssignCtrl* ctrl, 
		SOMObject* fromObj);
typedef somTP_KeyObject_somDefaultConstAssign *somTD_KeyObject_somDefaultConstAssign;
typedef KeyObject*   SOMLINK somTP_KeyObject_somDefaultVAssign(KeyObject *somSelf, 
		som3AssignCtrl* ctrl, 
		SOMObject* fromObj);
typedef somTP_KeyObject_somDefaultVAssign *somTD_KeyObject_somDefaultVAssign;
typedef KeyObject*   SOMLINK somTP_KeyObject_somDefaultConstVAssign(KeyObject *somSelf, 
		som3AssignCtrl* ctrl, 
		SOMObject* fromObj);
typedef somTP_KeyObject_somDefaultConstVAssign *somTD_KeyObject_somDefaultConstVAssign;
typedef void   SOMLINK somTP_KeyObject_somFree(KeyObject *somSelf);
typedef somTP_KeyObject_somFree *somTD_KeyObject_somFree;
typedef void   SOMLINK somTP_KeyObject_somUninit(KeyObject *somSelf);
typedef somTP_KeyObject_somUninit *somTD_KeyObject_somUninit;
typedef SOMClass*   SOMLINK somTP_KeyObject_somGetClass(KeyObject *somSelf);
typedef somTP_KeyObject_somGetClass *somTD_KeyObject_somGetClass;
typedef string   SOMLINK somTP_KeyObject_somGetClassName(KeyObject *somSelf);
typedef somTP_KeyObject_somGetClassName *somTD_KeyObject_somGetClassName;
typedef long   SOMLINK somTP_KeyObject_somGetSize(KeyObject *somSelf);
typedef somTP_KeyObject_somGetSize *somTD_KeyObject_somGetSize;
typedef boolean   SOMLINK somTP_KeyObject_somIsA(KeyObject *somSelf, 
		SOMClass* aClassObj);
typedef somTP_KeyObject_somIsA *somTD_KeyObject_somIsA;
typedef boolean   SOMLINK somTP_KeyObject_somIsInstanceOf(KeyObject *somSelf, 
		SOMClass* aClassObj);
typedef somTP_KeyObject_somIsInstanceOf *somTD_KeyObject_somIsInstanceOf;
typedef boolean   SOMLINK somTP_KeyObject_somRespondsTo(KeyObject *somSelf, 
		somId mId);
typedef somTP_KeyObject_somRespondsTo *somTD_KeyObject_somRespondsTo;
typedef boolean   SOMLINK somTP_KeyObject_somDispatch(KeyObject *somSelf, 
		somToken* retValue, 
		somId methodId, 
		va_list ap);
typedef somTP_KeyObject_somDispatch *somTD_KeyObject_somDispatch;
typedef boolean   SOMLINK somTP_KeyObject_somClassDispatch(KeyObject *somSelf, 
		SOMClass* clsObj, 
		somToken* retValue, 
		somId methodId, 
		va_list ap);
typedef somTP_KeyObject_somClassDispatch *somTD_KeyObject_somClassDispatch;
typedef boolean   SOMLINK somTP_KeyObject_somCastObj(KeyObject *somSelf, 
		SOMClass* cls);
typedef somTP_KeyObject_somCastObj *somTD_KeyObject_somCastObj;
typedef boolean   SOMLINK somTP_KeyObject_somResetObj(KeyObject *somSelf);
typedef somTP_KeyObject_somResetObj *somTD_KeyObject_somResetObj;
typedef void   SOMLINK somTP_KeyObject_somDispatchV(KeyObject *somSelf, 
		somId methodId, 
		somId descriptor, 
		va_list ap);
typedef somTP_KeyObject_somDispatchV *somTD_KeyObject_somDispatchV;
typedef long   SOMLINK somTP_KeyObject_somDispatchL(KeyObject *somSelf, 
		somId methodId, 
		somId descriptor, 
		va_list ap);
typedef somTP_KeyObject_somDispatchL *somTD_KeyObject_somDispatchL;
typedef void*   SOMLINK somTP_KeyObject_somDispatchA(KeyObject *somSelf, 
		somId methodId, 
		somId descriptor, 
		va_list ap);
typedef somTP_KeyObject_somDispatchA *somTD_KeyObject_somDispatchA;
typedef double   SOMLINK somTP_KeyObject_somDispatchD(KeyObject *somSelf, 
		somId methodId, 
		somId descriptor, 
		va_list ap);
typedef somTP_KeyObject_somDispatchD *somTD_KeyObject_somDispatchD;
typedef SOMObject*   SOMLINK somTP_KeyObject_somPrintSelf(KeyObject *somSelf);
typedef somTP_KeyObject_somPrintSelf *somTD_KeyObject_somPrintSelf;
typedef void   SOMLINK somTP_KeyObject_somDumpSelf(KeyObject *somSelf, 
		long level);
typedef somTP_KeyObject_somDumpSelf *somTD_KeyObject_somDumpSelf;
typedef void   SOMLINK somTP_KeyObject_somDumpSelfInt(KeyObject *somSelf, 
		long level);
typedef somTP_KeyObject_somDumpSelfInt *somTD_KeyObject_somDumpSelfInt;
}

#endif /* KeyObject_API */


/*
 * -- This emitter treats Method Tokens as Thunks by default.
 * -- Use the sc modifier "nothunks" to change this default
 */
#undef somresolve_
#define somresolve_(obj,mToken) ((somMethodProc*)((void)obj, mToken))

/*
 * -- The C++ Wrapper Class for KeyObject
 */
class KeyObject : public somf_TCollectibleLong
{
public:

// KeyObject::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 (!_KeyObject) KeyObjectNewClass(KeyObject_MajorVersion,KeyObject_MinorVersion);
   return (void*)
      SOM_Resolve(_KeyObject,SOMClass,somNewNoInit)
         ((SOMClass *)((void*)_KeyObject));
}

// KeyObject::delete uses somDestruct.
void operator delete(void * obj)
{
   if (obj && *(void**)obj) {
      SOM_Resolve(obj,SOMObject,somFree)
         ((SOMObject*)obj);
   }
}

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

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

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

#ifdef __IBMCPP__
#pragma info(nocnv,nopar)
#endif
KeyObject(const KeyObject* fromObj)
{
   if (*(void**)this != 
       ((somParentMtabStructPtr)
        (KeyObjectCClassData.parentMtab))->mtab)
      return;
   ((SOMObject*)((void*)this))->somDefaultConstCopyInit(0,((SOMObject*)((void*)fromObj)));
}
#ifdef __IBMCPP__
#pragma info(restore)
#endif


/*
 * Reintroduce inherited methods
 */

/* method: somfTCollectibleLongInit */
somf_TCollectibleLong*   somfTCollectibleLongInit(Environment *ev, 
		long v)
{
/*
 *  Initializes the new set.
 */
   return SOM_ResolveD(this,KeyObject,somf_TCollectibleLong,somfTCollectibleLongInit)
	(this, ev,v);
}


/* method: somfGetValue */
long   somfGetValue(Environment *ev)
{
/*
 *  Determine the value of the long.
 */
   return SOM_ResolveD(this,KeyObject,somf_TCollectibleLong,somfGetValue)
	(this, ev);
}


/* method: somfSetValue */
void   somfSetValue(Environment *ev, 
		long v)
{
/*
 *  Set the value of the long in the TCollectibleLong
 */
   SOM_ResolveD(this,KeyObject,somf_TCollectibleLong,somfSetValue)
	(this, ev,v);
}


/* method: somInit */
void   somInit()
{
   SOM_ResolveD(this,KeyObject,SOMObject,somInit)
	(this);
}


/* method: somfIsEqual */
boolean   somfIsEqual(Environment *ev, 
		somf_MCollectible* obj)
{
   return SOM_ResolveD(this,KeyObject,somf_MCollectible,somfIsEqual)
	(this, ev,obj);
}


/* method: somfHash */
long   somfHash(Environment *ev)
{
   return SOM_ResolveD(this,KeyObject,somf_MCollectible,somfHash)
	(this, ev);
}


/* method: somfClone */
somf_MCollectible*   somfClone(Environment *ev)
{
/*
 *  somfClone provides a general function for creating a new instance of this.
 */
   return SOM_ResolveD(this,KeyObject,somf_MCollectible,somfClone)
	(this, ev);
}


/* method: somfClonePointer */
somf_MCollectible*   somfClonePointer(Environment *ev, 
		somf_MCollectible* clonee)
{
/*
 *  somfClonePointer returns a pointer to a Clone
 */
   return SOM_ResolveD(this,KeyObject,somf_MCollectible,somfClonePointer)
	(this, ev,clonee);
}


/* method: somfIsSame */
boolean   somfIsSame(Environment *ev, 
		somf_MCollectible* obj)
{
/*
 *  The default function for somfIsSame is a pointer comparison
 */
   return SOM_ResolveD(this,KeyObject,somf_MCollectible,somfIsSame)
	(this, ev,obj);
}


/* method: somfIsNotEqual */
boolean   somfIsNotEqual(Environment *ev, 
		somf_MCollectible* obj)
{
/*
 *  somfIsNotEqual returns TRUE if obj is NOT isomorphic to this.  It uses
 *  somfIsEqual, so overriding somfIsEqual will handle the logic of somfIsNotEqual too.
 */
   return SOM_ResolveD(this,KeyObject,somf_MCollectible,somfIsNotEqual)
	(this, ev,obj);
}


/* 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_ResolveD(this,KeyObject,SOMObject,somDefaultInit)
	(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_ResolveD(this,KeyObject,SOMObject,somDestruct)
	(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_ResolveD(this,KeyObject,SOMObject,somDefaultCopyInit)
	(this,ctrl,fromObj);
}


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


/* initializer method: somDefaultConstCopyInit */
void   somDefaultConstCopyInit(som3InitCtrl* ctrl, 
		SOMObject* fromObj)
{
/*
 *  A default copy constructor that uses a const fromObj.
 */
   SOM_ResolveD(this,KeyObject,SOMObject,somDefaultConstCopyInit)
	(this,ctrl,fromObj);
}


/* initializer method: somDefaultVCopyInit */
void   somDefaultVCopyInit(som3InitCtrl* ctrl, 
		SOMObject* fromObj)
{
/*
 *  A default copy constructor that uses a volatile fromObj.
 */
   SOM_ResolveD(this,KeyObject,SOMObject,somDefaultVCopyInit)
	(this,ctrl,fromObj);
}


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


/* method: somDefaultConstAssign */
KeyObject*  somDefaultConstAssign(som3AssignCtrl* ctrl, 
		SOMObject* fromObj)
{
/*
 *  A default assignment operator that uses a const fromObj.
 */
   return SOM_ResolveD(this,KeyObject,SOMObject,somDefaultConstAssign)
	(this,ctrl,fromObj);
}


/* method: somDefaultVAssign */
KeyObject*  somDefaultVAssign(som3AssignCtrl* ctrl, 
		SOMObject* fromObj)
{
/*
 *  A default assignment operator that uses a volatile fromObj.
 */
   return SOM_ResolveD(this,KeyObject,SOMObject,somDefaultVAssign)
	(this,ctrl,fromObj);
}


/* method: somDefaultConstVAssign */
KeyObject*  somDefaultConstVAssign(som3AssignCtrl* ctrl, 
		SOMObject* fromObj)
{
/*
 *  A default assignment operator that uses a const volatile fromObj.
 */
   return SOM_ResolveD(this,KeyObject,SOMObject,somDefaultConstVAssign)
	(this,ctrl,fromObj);
}


/* method: somFree */
void   somFree()
{
/*
 *  Use as directed by framework implementations.
 */
   SOM_ResolveD(this,KeyObject,SOMObject,somFree)
	(this);
}


/* method: somUninit */
void   somUninit()
{
/*
 *  Obsolete but still supported. Override somDestruct instead of somUninit.
 */
   SOM_ResolveD(this,KeyObject,SOMObject,somUninit)
	(this);
}


/* method: somGetClass */
SOMClass*   somGetClass()
{
/*
 *  Return the receiver's class.
 */
   return SOM_ResolveD(this,KeyObject,SOMObject,somGetClass)
	(this);
}


/* method: somGetClassName */
string   somGetClassName()
{
/*
 *  Return the name of the receiver's class.
 */
   return SOM_ResolveD(this,KeyObject,SOMObject,somGetClassName)
	(this);
}


/* method: somGetSize */
long   somGetSize()
{
/*
 *  Return the size of the receiver.
 */
   return SOM_ResolveD(this,KeyObject,SOMObject,somGetSize)
	(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_ResolveD(this,KeyObject,SOMObject,somIsA)
	(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_ResolveD(this,KeyObject,SOMObject,somIsInstanceOf)
	(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_ResolveD(this,KeyObject,SOMObject,somRespondsTo)
	(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.
 */
/* the va_list invocation form */
boolean   KeyObject_somDispatch(somToken* retValue, 
		somId methodId, 
		va_list ap)
{return SOM_ResolveD(this,KeyObject,SOMObject,somDispatch)
	(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.
 */
   va_list ap;
   va_start(ap, methodId);
   boolean __somResult = 
      SOM_ResolveD(this,KeyObject,SOMObject,somDispatch)
	(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   KeyObject_somClassDispatch(SOMClass* clsObj, 
		somToken* retValue, 
		somId methodId, 
		va_list ap)
{return SOM_ResolveD(this,KeyObject,SOMObject,somClassDispatch)
	(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_ResolveD(this,KeyObject,SOMObject,somClassDispatch)
	(this,clsObj,retValue,methodId,ap);
   va_end(ap);
   return __somResult;
}


/* method: somCastObj */
boolean   somCastObj(SOMClass* cls)
{
/*
 *  cast the receiving object to cls (which must be an ancestor of the
 *  objects true class. Returns true on success.
 */
   return SOM_ResolveD(this,KeyObject,SOMObject,somCastObj)
	(this,cls);
}


/* method: somResetObj */
boolean   somResetObj()
{
/*
 *  reset an object to its true class. Returns true always.
 */
   return SOM_ResolveD(this,KeyObject,SOMObject,somResetObj)
	(this);
}


/* va_list method: somDispatchV */

/*
 *  Obsolete. Use somDispatch instead.
 */
/* the va_list invocation form */
void   KeyObject_somDispatchV(somId methodId, 
		somId descriptor, 
		va_list ap)
{   SOM_ResolveD(this,KeyObject,SOMObject,somDispatchV)
	(this,methodId,descriptor,ap);
}

/* the varargs invocation form */
void   somDispatchV(somId methodId, 
		somId descriptor, 
		...)
{
/*
 *  Obsolete. Use somDispatch instead.
 */
   va_list ap;
   va_start(ap, descriptor);
   SOM_ResolveD(this,KeyObject,SOMObject,somDispatchV)
	(this,methodId,descriptor,ap);
   va_end(ap);
}


/* va_list method: somDispatchL */

/*
 *  Obsolete. Use somDispatch instead.
 */
/* the va_list invocation form */
long   KeyObject_somDispatchL(somId methodId, 
		somId descriptor, 
		va_list ap)
{return SOM_ResolveD(this,KeyObject,SOMObject,somDispatchL)
	(this,methodId,descriptor,ap);
}

/* the varargs invocation form */
long   somDispatchL(somId methodId, 
		somId descriptor, 
		...)
{
/*
 *  Obsolete. Use somDispatch instead.
 */
   va_list ap;
   va_start(ap, descriptor);
   long __somResult = 
      SOM_ResolveD(this,KeyObject,SOMObject,somDispatchL)
	(this,methodId,descriptor,ap);
   va_end(ap);
   return __somResult;
}


/* va_list method: somDispatchA */

/*
 *  Obsolete. Use somDispatch instead.
 */
/* the va_list invocation form */
void*   KeyObject_somDispatchA(somId methodId, 
		somId descriptor, 
		va_list ap)
{return SOM_ResolveD(this,KeyObject,SOMObject,somDispatchA)
	(this,methodId,descriptor,ap);
}

/* the varargs invocation form */
void*   somDispatchA(somId methodId, 
		somId descriptor, 
		...)
{
/*
 *  Obsolete. Use somDispatch instead.
 */
   va_list ap;
   va_start(ap, descriptor);
   void* __somResult = 
      SOM_ResolveD(this,KeyObject,SOMObject,somDispatchA)
	(this,methodId,descriptor,ap);
   va_end(ap);
   return __somResult;
}


/* va_list method: somDispatchD */

/*
 *  Obsolete. Use somDispatch instead.
 */
/* the va_list invocation form */
double   KeyObject_somDispatchD(somId methodId, 
		somId descriptor, 
		va_list ap)
{return SOM_ResolveD(this,KeyObject,SOMObject,somDispatchD)
	(this,methodId,descriptor,ap);
}

/* the varargs invocation form */
double   somDispatchD(somId methodId, 
		somId descriptor, 
		...)
{
/*
 *  Obsolete. Use somDispatch instead.
 */
   va_list ap;
   va_start(ap, descriptor);
   double __somResult = 
      SOM_ResolveD(this,KeyObject,SOMObject,somDispatchD)
	(this,methodId,descriptor,ap);
   va_end(ap);
   return __somResult;
}


/* method: somPrintSelf */
SOMObject*   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_ResolveD(this,KeyObject,SOMObject,somPrintSelf)
	(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_ResolveD(this,KeyObject,SOMObject,somDumpSelf)
	(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_ResolveD(this,KeyObject,SOMObject,somDumpSelfInt)
	(this,level);
}



};   /* KeyObject */



#endif       /* SOM_KeyObject_xh */

#ifndef SOM_ProductObject_xh
#define SOM_ProductObject_xh

class ProductObject;

#define ProductObject_MajorVersion 2
#define ProductObject_MinorVersion 1

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

/* C++ parent defs */
#ifndef SOM_somf_MCollectible_xh
#include <mcollect.xh>
#endif

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

/*
 * Start of bindings for IDL types
 */


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

/* A procedure to create the ProductObject Class */
SOMEXTERN SOMClass * SOMLINK ProductObjectNewClass(
		integer4 majorVersion,
		integer4 minorVersion);

/* The API to the ProductObject class object, and the methods it introduces. */
SOMEXTERN struct ProductObjectClassDataStructure {
	SOMClass *classObject;
	somMToken _get_productName;
	somMToken _set_productName;
} SOMDLINK ProductObjectClassData;
#define _ProductObject ProductObjectClassData.classObject

/* The API to parentMtabs for ProductObject, and the instance data it introduces. */
SOMEXTERN struct ProductObjectCClassDataStructure {
	somMethodTabs parentMtab;
	somDToken              instanceDataToken;
} SOMDLINK ProductObjectCClassData;

/*
 * -- Typedefs for ProductObject Method Procedures
 */
SOMEXTERN {
typedef string   SOMLINK somTP_ProductObject__get_productName(ProductObject *somSelf, Environment *ev);
typedef somTP_ProductObject__get_productName *somTD_ProductObject__get_productName;
typedef void   SOMLINK somTP_ProductObject__set_productName(ProductObject *somSelf, Environment *ev, 
		string productName);
typedef somTP_ProductObject__set_productName *somTD_ProductObject__set_productName;

/*
 * -- Typedefs for Reintroduced Wrapper Methods
 */
typedef somf_MCollectible*   SOMLINK somTP_ProductObject_somfClone(ProductObject *somSelf, Environment *ev);
typedef somTP_ProductObject_somfClone *somTD_ProductObject_somfClone;
typedef somf_MCollectible*   SOMLINK somTP_ProductObject_somfClonePointer(ProductObject *somSelf, Environment *ev, 
		somf_MCollectible* clonee);
typedef somTP_ProductObject_somfClonePointer *somTD_ProductObject_somfClonePointer;
typedef long   SOMLINK somTP_ProductObject_somfHash(ProductObject *somSelf, Environment *ev);
typedef somTP_ProductObject_somfHash *somTD_ProductObject_somfHash;
typedef boolean   SOMLINK somTP_ProductObject_somfIsEqual(ProductObject *somSelf, Environment *ev, 
		somf_MCollectible* obj);
typedef somTP_ProductObject_somfIsEqual *somTD_ProductObject_somfIsEqual;
typedef boolean   SOMLINK somTP_ProductObject_somfIsSame(ProductObject *somSelf, Environment *ev, 
		somf_MCollectible* obj);
typedef somTP_ProductObject_somfIsSame *somTD_ProductObject_somfIsSame;
typedef boolean   SOMLINK somTP_ProductObject_somfIsNotEqual(ProductObject *somSelf, Environment *ev, 
		somf_MCollectible* obj);
typedef somTP_ProductObject_somfIsNotEqual *somTD_ProductObject_somfIsNotEqual;
typedef void   SOMLINK somTP_ProductObject_somDefaultInit(ProductObject *somSelf, 
		som3InitCtrl* ctrl);
typedef somTP_ProductObject_somDefaultInit *somTD_ProductObject_somDefaultInit;
typedef void   SOMLINK somTP_ProductObject_somDestruct(ProductObject *somSelf, 
		octet doFree, 
		som3DestructCtrl* ctrl);
typedef somTP_ProductObject_somDestruct *somTD_ProductObject_somDestruct;
typedef void   SOMLINK somTP_ProductObject_somDefaultCopyInit(ProductObject *somSelf, 
		som3InitCtrl* ctrl, 
		SOMObject* fromObj);
typedef somTP_ProductObject_somDefaultCopyInit *somTD_ProductObject_somDefaultCopyInit;
typedef ProductObject*   SOMLINK somTP_ProductObject_somDefaultAssign(ProductObject *somSelf, 
		som3AssignCtrl* ctrl, 
		SOMObject* fromObj);
typedef somTP_ProductObject_somDefaultAssign *somTD_ProductObject_somDefaultAssign;
typedef void   SOMLINK somTP_ProductObject_somDefaultConstCopyInit(ProductObject *somSelf, 
		som3InitCtrl* ctrl, 
		SOMObject* fromObj);
typedef somTP_ProductObject_somDefaultConstCopyInit *somTD_ProductObject_somDefaultConstCopyInit;
typedef void   SOMLINK somTP_ProductObject_somDefaultVCopyInit(ProductObject *somSelf, 
		som3InitCtrl* ctrl, 
		SOMObject* fromObj);
typedef somTP_ProductObject_somDefaultVCopyInit *somTD_ProductObject_somDefaultVCopyInit;
typedef void   SOMLINK somTP_ProductObject_somDefaultConstVCopyInit(ProductObject *somSelf, 
		som3InitCtrl* ctrl, 
		SOMObject* fromObj);
typedef somTP_ProductObject_somDefaultConstVCopyInit *somTD_ProductObject_somDefaultConstVCopyInit;
typedef ProductObject*   SOMLINK somTP_ProductObject_somDefaultConstAssign(ProductObject *somSelf, 
		som3AssignCtrl* ctrl, 
		SOMObject* fromObj);
typedef somTP_ProductObject_somDefaultConstAssign *somTD_ProductObject_somDefaultConstAssign;
typedef ProductObject*   SOMLINK somTP_ProductObject_somDefaultVAssign(ProductObject *somSelf, 
		som3AssignCtrl* ctrl, 
		SOMObject* fromObj);
typedef somTP_ProductObject_somDefaultVAssign *somTD_ProductObject_somDefaultVAssign;
typedef ProductObject*   SOMLINK somTP_ProductObject_somDefaultConstVAssign(ProductObject *somSelf, 
		som3AssignCtrl* ctrl, 
		SOMObject* fromObj);
typedef somTP_ProductObject_somDefaultConstVAssign *somTD_ProductObject_somDefaultConstVAssign;
typedef void   SOMLINK somTP_ProductObject_somInit(ProductObject *somSelf);
typedef somTP_ProductObject_somInit *somTD_ProductObject_somInit;
typedef void   SOMLINK somTP_ProductObject_somFree(ProductObject *somSelf);
typedef somTP_ProductObject_somFree *somTD_ProductObject_somFree;
typedef void   SOMLINK somTP_ProductObject_somUninit(ProductObject *somSelf);
typedef somTP_ProductObject_somUninit *somTD_ProductObject_somUninit;
typedef SOMClass*   SOMLINK somTP_ProductObject_somGetClass(ProductObject *somSelf);
typedef somTP_ProductObject_somGetClass *somTD_ProductObject_somGetClass;
typedef string   SOMLINK somTP_ProductObject_somGetClassName(ProductObject *somSelf);
typedef somTP_ProductObject_somGetClassName *somTD_ProductObject_somGetClassName;
typedef long   SOMLINK somTP_ProductObject_somGetSize(ProductObject *somSelf);
typedef somTP_ProductObject_somGetSize *somTD_ProductObject_somGetSize;
typedef boolean   SOMLINK somTP_ProductObject_somIsA(ProductObject *somSelf, 
		SOMClass* aClassObj);
typedef somTP_ProductObject_somIsA *somTD_ProductObject_somIsA;
typedef boolean   SOMLINK somTP_ProductObject_somIsInstanceOf(ProductObject *somSelf, 
		SOMClass* aClassObj);
typedef somTP_ProductObject_somIsInstanceOf *somTD_ProductObject_somIsInstanceOf;
typedef boolean   SOMLINK somTP_ProductObject_somRespondsTo(ProductObject *somSelf, 
		somId mId);
typedef somTP_ProductObject_somRespondsTo *somTD_ProductObject_somRespondsTo;
typedef boolean   SOMLINK somTP_ProductObject_somDispatch(ProductObject *somSelf, 
		somToken* retValue, 
		somId methodId, 
		va_list ap);
typedef somTP_ProductObject_somDispatch *somTD_ProductObject_somDispatch;
typedef boolean   SOMLINK somTP_ProductObject_somClassDispatch(ProductObject *somSelf, 
		SOMClass* clsObj, 
		somToken* retValue, 
		somId methodId, 
		va_list ap);
typedef somTP_ProductObject_somClassDispatch *somTD_ProductObject_somClassDispatch;
typedef boolean   SOMLINK somTP_ProductObject_somCastObj(ProductObject *somSelf, 
		SOMClass* cls);
typedef somTP_ProductObject_somCastObj *somTD_ProductObject_somCastObj;
typedef boolean   SOMLINK somTP_ProductObject_somResetObj(ProductObject *somSelf);
typedef somTP_ProductObject_somResetObj *somTD_ProductObject_somResetObj;
typedef void   SOMLINK somTP_ProductObject_somDispatchV(ProductObject *somSelf, 
		somId methodId, 
		somId descriptor, 
		va_list ap);
typedef somTP_ProductObject_somDispatchV *somTD_ProductObject_somDispatchV;
typedef long   SOMLINK somTP_ProductObject_somDispatchL(ProductObject *somSelf, 
		somId methodId, 
		somId descriptor, 
		va_list ap);
typedef somTP_ProductObject_somDispatchL *somTD_ProductObject_somDispatchL;
typedef void*   SOMLINK somTP_ProductObject_somDispatchA(ProductObject *somSelf, 
		somId methodId, 
		somId descriptor, 
		va_list ap);
typedef somTP_ProductObject_somDispatchA *somTD_ProductObject_somDispatchA;
typedef double   SOMLINK somTP_ProductObject_somDispatchD(ProductObject *somSelf, 
		somId methodId, 
		somId descriptor, 
		va_list ap);
typedef somTP_ProductObject_somDispatchD *somTD_ProductObject_somDispatchD;
typedef SOMObject*   SOMLINK somTP_ProductObject_somPrintSelf(ProductObject *somSelf);
typedef somTP_ProductObject_somPrintSelf *somTD_ProductObject_somPrintSelf;
typedef void   SOMLINK somTP_ProductObject_somDumpSelf(ProductObject *somSelf, 
		long level);
typedef somTP_ProductObject_somDumpSelf *somTD_ProductObject_somDumpSelf;
typedef void   SOMLINK somTP_ProductObject_somDumpSelfInt(ProductObject *somSelf, 
		long level);
typedef somTP_ProductObject_somDumpSelfInt *somTD_ProductObject_somDumpSelfInt;
}

#endif /* ProductObject_API */


/*
 * -- This emitter treats Method Tokens as Thunks by default.
 * -- Use the sc modifier "nothunks" to change this default
 */
#undef somresolve_
#define somresolve_(obj,mToken) ((somMethodProc*)((void)obj, mToken))

/*
 * -- The C++ Wrapper Class for ProductObject
 */
class ProductObject : public somf_MCollectible
{
public:

// ProductObject::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 (!_ProductObject) ProductObjectNewClass(ProductObject_MajorVersion,ProductObject_MinorVersion);
   return (void*)
      SOM_Resolve(_ProductObject,SOMClass,somNewNoInit)
         ((SOMClass *)((void*)_ProductObject));
}

// ProductObject::delete uses somDestruct.
void operator delete(void * obj)
{
   if (obj && *(void**)obj) {
      SOM_Resolve(obj,SOMObject,somFree)
         ((SOMObject*)obj);
   }
}

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

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

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

#ifdef __IBMCPP__
#pragma info(nocnv,nopar)
#endif
ProductObject(const ProductObject* fromObj)
{
   if (*(void**)this != 
       ((somParentMtabStructPtr)
        (ProductObjectCClassData.parentMtab))->mtab)
      return;
   ((SOMObject*)((void*)this))->somDefaultConstCopyInit(0,((SOMObject*)((void*)fromObj)));
}
#ifdef __IBMCPP__
#pragma info(restore)
#endif


/* method: _get_productName */
string   _get_productName(Environment *ev)
{
/*
 * Method from the IDL attribute statement:
 * "attribute string productName"
 */
   return SOM_ResolveD(this,ProductObject,ProductObject,_get_productName)
	(this, ev);
}


/* method: _set_productName */
void   _set_productName(Environment *ev, 
		string productName)
{
/*
 * Method from the IDL attribute statement:
 * "attribute string productName"
 */
   SOM_ResolveD(this,ProductObject,ProductObject,_set_productName)
	(this, ev,productName);
}


/*
 * Reintroduce inherited methods
 */

/* method: somfClone */
somf_MCollectible*   somfClone(Environment *ev)
{
/*
 *  somfClone provides a general function for creating a new instance of this.
 */
   return SOM_ResolveD(this,ProductObject,somf_MCollectible,somfClone)
	(this, ev);
}


/* method: somfClonePointer */
somf_MCollectible*   somfClonePointer(Environment *ev, 
		somf_MCollectible* clonee)
{
/*
 *  somfClonePointer returns a pointer to a Clone
 */
   return SOM_ResolveD(this,ProductObject,somf_MCollectible,somfClonePointer)
	(this, ev,clonee);
}


/* method: somfHash */
long   somfHash(Environment *ev)
{
/*
 *  somfHash returns a value suitable for use as a hashing probe for this.
 *  The default function will simply return the address of the object.
 *  The default function is almost certainly not adequate if you are overriding
 *  somfIsEqual because you need to make sure that all objects that "are equal"
 *  to each other return the same hash value.  For example, a TText object would
 *  return a hash value computed using the characters in the string instead of
 *  the address of the string.
 */
   return SOM_ResolveD(this,ProductObject,somf_MCollectible,somfHash)
	(this, ev);
}


/* method: somfIsEqual */
boolean   somfIsEqual(Environment *ev, 
		somf_MCollectible* obj)
{
/*
 *  somfIsEqual returns TRUE if obj is isomorphic to this.  The default function
 *  will give you a nasty message.  For example, the somfIsEqual method
 *  for TText objects will do a string comparison.  All of the utility classes
 *  allow you to specify what methods to use when comparing objects for
 *  insertion, deletion, etc.
 */
   return SOM_ResolveD(this,ProductObject,somf_MCollectible,somfIsEqual)
	(this, ev,obj);
}


/* method: somfIsSame */
boolean   somfIsSame(Environment *ev, 
		somf_MCollectible* obj)
{
/*
 *  The default function for somfIsSame is a pointer comparison
 */
   return SOM_ResolveD(this,ProductObject,somf_MCollectible,somfIsSame)
	(this, ev,obj);
}


/* method: somfIsNotEqual */
boolean   somfIsNotEqual(Environment *ev, 
		somf_MCollectible* obj)
{
/*
 *  somfIsNotEqual returns TRUE if obj is NOT isomorphic to this.  It uses
 *  somfIsEqual, so overriding somfIsEqual will handle the logic of somfIsNotEqual too.
 */
   return SOM_ResolveD(this,ProductObject,somf_MCollectible,somfIsNotEqual)
	(this, ev,obj);
}


/* 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_ResolveD(this,ProductObject,SOMObject,somDefaultInit)
	(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_ResolveD(this,ProductObject,SOMObject,somDestruct)
	(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_ResolveD(this,ProductObject,SOMObject,somDefaultCopyInit)
	(this,ctrl,fromObj);
}


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


/* initializer method: somDefaultConstCopyInit */
void   somDefaultConstCopyInit(som3InitCtrl* ctrl, 
		SOMObject* fromObj)
{
/*
 *  A default copy constructor that uses a const fromObj.
 */
   SOM_ResolveD(this,ProductObject,SOMObject,somDefaultConstCopyInit)
	(this,ctrl,fromObj);
}


/* initializer method: somDefaultVCopyInit */
void   somDefaultVCopyInit(som3InitCtrl* ctrl, 
		SOMObject* fromObj)
{
/*
 *  A default copy constructor that uses a volatile fromObj.
 */
   SOM_ResolveD(this,ProductObject,SOMObject,somDefaultVCopyInit)
	(this,ctrl,fromObj);
}


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


/* method: somDefaultConstAssign */
ProductObject*  somDefaultConstAssign(som3AssignCtrl* ctrl, 
		SOMObject* fromObj)
{
/*
 *  A default assignment operator that uses a const fromObj.
 */
   return SOM_ResolveD(this,ProductObject,SOMObject,somDefaultConstAssign)
	(this,ctrl,fromObj);
}


/* method: somDefaultVAssign */
ProductObject*  somDefaultVAssign(som3AssignCtrl* ctrl, 
		SOMObject* fromObj)
{
/*
 *  A default assignment operator that uses a volatile fromObj.
 */
   return SOM_ResolveD(this,ProductObject,SOMObject,somDefaultVAssign)
	(this,ctrl,fromObj);
}


/* method: somDefaultConstVAssign */
ProductObject*  somDefaultConstVAssign(som3AssignCtrl* ctrl, 
		SOMObject* fromObj)
{
/*
 *  A default assignment operator that uses a const volatile fromObj.
 */
   return SOM_ResolveD(this,ProductObject,SOMObject,somDefaultConstVAssign)
	(this,ctrl,fromObj);
}


/* method: somInit */
void   somInit()
{
/*
 *  Obsolete but still supported. Override somDefaultInit instead of somInit.
 */
   SOM_ResolveD(this,ProductObject,SOMObject,somInit)
	(this);
}


/* method: somFree */
void   somFree()
{
/*
 *  Use as directed by framework implementations.
 */
   SOM_ResolveD(this,ProductObject,SOMObject,somFree)
	(this);
}


/* method: somUninit */
void   somUninit()
{
/*
 *  Obsolete but still supported. Override somDestruct instead of somUninit.
 */
   SOM_ResolveD(this,ProductObject,SOMObject,somUninit)
	(this);
}


/* method: somGetClass */
SOMClass*   somGetClass()
{
/*
 *  Return the receiver's class.
 */
   return SOM_ResolveD(this,ProductObject,SOMObject,somGetClass)
	(this);
}


/* method: somGetClassName */
string   somGetClassName()
{
/*
 *  Return the name of the receiver's class.
 */
   return SOM_ResolveD(this,ProductObject,SOMObject,somGetClassName)
	(this);
}


/* method: somGetSize */
long   somGetSize()
{
/*
 *  Return the size of the receiver.
 */
   return SOM_ResolveD(this,ProductObject,SOMObject,somGetSize)
	(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_ResolveD(this,ProductObject,SOMObject,somIsA)
	(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_ResolveD(this,ProductObject,SOMObject,somIsInstanceOf)
	(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_ResolveD(this,ProductObject,SOMObject,somRespondsTo)
	(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.
 */
/* the va_list invocation form */
boolean   ProductObject_somDispatch(somToken* retValue, 
		somId methodId, 
		va_list ap)
{return SOM_ResolveD(this,ProductObject,SOMObject,somDispatch)
	(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.
 */
   va_list ap;
   va_start(ap, methodId);
   boolean __somResult = 
      SOM_ResolveD(this,ProductObject,SOMObject,somDispatch)
	(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   ProductObject_somClassDispatch(SOMClass* clsObj, 
		somToken* retValue, 
		somId methodId, 
		va_list ap)
{return SOM_ResolveD(this,ProductObject,SOMObject,somClassDispatch)
	(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_ResolveD(this,ProductObject,SOMObject,somClassDispatch)
	(this,clsObj,retValue,methodId,ap);
   va_end(ap);
   return __somResult;
}


/* method: somCastObj */
boolean   somCastObj(SOMClass* cls)
{
/*
 *  cast the receiving object to cls (which must be an ancestor of the
 *  objects true class. Returns true on success.
 */
   return SOM_ResolveD(this,ProductObject,SOMObject,somCastObj)
	(this,cls);
}


/* method: somResetObj */
boolean   somResetObj()
{
/*
 *  reset an object to its true class. Returns true always.
 */
   return SOM_ResolveD(this,ProductObject,SOMObject,somResetObj)
	(this);
}


/* va_list method: somDispatchV */

/*
 *  Obsolete. Use somDispatch instead.
 */
/* the va_list invocation form */
void   ProductObject_somDispatchV(somId methodId, 
		somId descriptor, 
		va_list ap)
{   SOM_ResolveD(this,ProductObject,SOMObject,somDispatchV)
	(this,methodId,descriptor,ap);
}

/* the varargs invocation form */
void   somDispatchV(somId methodId, 
		somId descriptor, 
		...)
{
/*
 *  Obsolete. Use somDispatch instead.
 */
   va_list ap;
   va_start(ap, descriptor);
   SOM_ResolveD(this,ProductObject,SOMObject,somDispatchV)
	(this,methodId,descriptor,ap);
   va_end(ap);
}


/* va_list method: somDispatchL */

/*
 *  Obsolete. Use somDispatch instead.
 */
/* the va_list invocation form */
long   ProductObject_somDispatchL(somId methodId, 
		somId descriptor, 
		va_list ap)
{return SOM_ResolveD(this,ProductObject,SOMObject,somDispatchL)
	(this,methodId,descriptor,ap);
}

/* the varargs invocation form */
long   somDispatchL(somId methodId, 
		somId descriptor, 
		...)
{
/*
 *  Obsolete. Use somDispatch instead.
 */
   va_list ap;
   va_start(ap, descriptor);
   long __somResult = 
      SOM_ResolveD(this,ProductObject,SOMObject,somDispatchL)
	(this,methodId,descriptor,ap);
   va_end(ap);
   return __somResult;
}


/* va_list method: somDispatchA */

/*
 *  Obsolete. Use somDispatch instead.
 */
/* the va_list invocation form */
void*   ProductObject_somDispatchA(somId methodId, 
		somId descriptor, 
		va_list ap)
{return SOM_ResolveD(this,ProductObject,SOMObject,somDispatchA)
	(this,methodId,descriptor,ap);
}

/* the varargs invocation form */
void*   somDispatchA(somId methodId, 
		somId descriptor, 
		...)
{
/*
 *  Obsolete. Use somDispatch instead.
 */
   va_list ap;
   va_start(ap, descriptor);
   void* __somResult = 
      SOM_ResolveD(this,ProductObject,SOMObject,somDispatchA)
	(this,methodId,descriptor,ap);
   va_end(ap);
   return __somResult;
}


/* va_list method: somDispatchD */

/*
 *  Obsolete. Use somDispatch instead.
 */
/* the va_list invocation form */
double   ProductObject_somDispatchD(somId methodId, 
		somId descriptor, 
		va_list ap)
{return SOM_ResolveD(this,ProductObject,SOMObject,somDispatchD)
	(this,methodId,descriptor,ap);
}

/* the varargs invocation form */
double   somDispatchD(somId methodId, 
		somId descriptor, 
		...)
{
/*
 *  Obsolete. Use somDispatch instead.
 */
   va_list ap;
   va_start(ap, descriptor);
   double __somResult = 
      SOM_ResolveD(this,ProductObject,SOMObject,somDispatchD)
	(this,methodId,descriptor,ap);
   va_end(ap);
   return __somResult;
}


/* method: somPrintSelf */
SOMObject*   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_ResolveD(this,ProductObject,SOMObject,somPrintSelf)
	(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_ResolveD(this,ProductObject,SOMObject,somDumpSelf)
	(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_ResolveD(this,ProductObject,SOMObject,somDumpSelfInt)
	(this,level);
}



};   /* ProductObject */



#endif       /* SOM_ProductObject_xh */

#ifndef SOM_VendorObject_xh
#define SOM_VendorObject_xh

class VendorObject;

#define VendorObject_MajorVersion 2
#define VendorObject_MinorVersion 1

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

/* C++ parent defs */
#ifndef SOM_somf_MCollectible_xh
#include <mcollect.xh>
#endif

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

/*
 * Start of bindings for IDL types
 */


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

/* A procedure to create the VendorObject Class */
SOMEXTERN SOMClass * SOMLINK VendorObjectNewClass(
		integer4 majorVersion,
		integer4 minorVersion);

/* The API to the VendorObject class object, and the methods it introduces. */
SOMEXTERN struct VendorObjectClassDataStructure {
	SOMClass *classObject;
	somMToken _get_vendorName;
	somMToken _set_vendorName;
	somMToken addProduct;
	somMToken findProduct;
} SOMDLINK VendorObjectClassData;
#define _VendorObject VendorObjectClassData.classObject

/* The API to parentMtabs for VendorObject, and the instance data it introduces. */
SOMEXTERN struct VendorObjectCClassDataStructure {
	somMethodTabs parentMtab;
	somDToken              instanceDataToken;
} SOMDLINK VendorObjectCClassData;

/*
 * -- Typedefs for VendorObject Method Procedures
 */
SOMEXTERN {
typedef string   SOMLINK somTP_VendorObject__get_vendorName(VendorObject *somSelf, Environment *ev);
typedef somTP_VendorObject__get_vendorName *somTD_VendorObject__get_vendorName;
typedef void   SOMLINK somTP_VendorObject__set_vendorName(VendorObject *somSelf, Environment *ev, 
		string vendorName);
typedef somTP_VendorObject__set_vendorName *somTD_VendorObject__set_vendorName;
typedef ProductObject*   SOMLINK somTP_VendorObject_addProduct(VendorObject *somSelf, Environment *ev, 
		long key, 
		string productName);
typedef somTP_VendorObject_addProduct *somTD_VendorObject_addProduct;
typedef ProductObject*   SOMLINK somTP_VendorObject_findProduct(VendorObject *somSelf, Environment *ev, 
		long key);
typedef somTP_VendorObject_findProduct *somTD_VendorObject_findProduct;

/*
 * -- Typedefs for Reintroduced Wrapper Methods
 */
typedef somf_MCollectible*   SOMLINK somTP_VendorObject_somfClone(VendorObject *somSelf, Environment *ev);
typedef somTP_VendorObject_somfClone *somTD_VendorObject_somfClone;
typedef somf_MCollectible*   SOMLINK somTP_VendorObject_somfClonePointer(VendorObject *somSelf, Environment *ev, 
		somf_MCollectible* clonee);
typedef somTP_VendorObject_somfClonePointer *somTD_VendorObject_somfClonePointer;
typedef long   SOMLINK somTP_VendorObject_somfHash(VendorObject *somSelf, Environment *ev);
typedef somTP_VendorObject_somfHash *somTD_VendorObject_somfHash;
typedef boolean   SOMLINK somTP_VendorObject_somfIsEqual(VendorObject *somSelf, Environment *ev, 
		somf_MCollectible* obj);
typedef somTP_VendorObject_somfIsEqual *somTD_VendorObject_somfIsEqual;
typedef boolean   SOMLINK somTP_VendorObject_somfIsSame(VendorObject *somSelf, Environment *ev, 
		somf_MCollectible* obj);
typedef somTP_VendorObject_somfIsSame *somTD_VendorObject_somfIsSame;
typedef boolean   SOMLINK somTP_VendorObject_somfIsNotEqual(VendorObject *somSelf, Environment *ev, 
		somf_MCollectible* obj);
typedef somTP_VendorObject_somfIsNotEqual *somTD_VendorObject_somfIsNotEqual;
typedef void   SOMLINK somTP_VendorObject_somDefaultInit(VendorObject *somSelf, 
		som3InitCtrl* ctrl);
typedef somTP_VendorObject_somDefaultInit *somTD_VendorObject_somDefaultInit;
typedef void   SOMLINK somTP_VendorObject_somDestruct(VendorObject *somSelf, 
		octet doFree, 
		som3DestructCtrl* ctrl);
typedef somTP_VendorObject_somDestruct *somTD_VendorObject_somDestruct;
typedef void   SOMLINK somTP_VendorObject_somDefaultCopyInit(VendorObject *somSelf, 
		som3InitCtrl* ctrl, 
		SOMObject* fromObj);
typedef somTP_VendorObject_somDefaultCopyInit *somTD_VendorObject_somDefaultCopyInit;
typedef VendorObject*   SOMLINK somTP_VendorObject_somDefaultAssign(VendorObject *somSelf, 
		som3AssignCtrl* ctrl, 
		SOMObject* fromObj);
typedef somTP_VendorObject_somDefaultAssign *somTD_VendorObject_somDefaultAssign;
typedef void   SOMLINK somTP_VendorObject_somDefaultConstCopyInit(VendorObject *somSelf, 
		som3InitCtrl* ctrl, 
		SOMObject* fromObj);
typedef somTP_VendorObject_somDefaultConstCopyInit *somTD_VendorObject_somDefaultConstCopyInit;
typedef void   SOMLINK somTP_VendorObject_somDefaultVCopyInit(VendorObject *somSelf, 
		som3InitCtrl* ctrl, 
		SOMObject* fromObj);
typedef somTP_VendorObject_somDefaultVCopyInit *somTD_VendorObject_somDefaultVCopyInit;
typedef void   SOMLINK somTP_VendorObject_somDefaultConstVCopyInit(VendorObject *somSelf, 
		som3InitCtrl* ctrl, 
		SOMObject* fromObj);
typedef somTP_VendorObject_somDefaultConstVCopyInit *somTD_VendorObject_somDefaultConstVCopyInit;
typedef VendorObject*   SOMLINK somTP_VendorObject_somDefaultConstAssign(VendorObject *somSelf, 
		som3AssignCtrl* ctrl, 
		SOMObject* fromObj);
typedef somTP_VendorObject_somDefaultConstAssign *somTD_VendorObject_somDefaultConstAssign;
typedef VendorObject*   SOMLINK somTP_VendorObject_somDefaultVAssign(VendorObject *somSelf, 
		som3AssignCtrl* ctrl, 
		SOMObject* fromObj);
typedef somTP_VendorObject_somDefaultVAssign *somTD_VendorObject_somDefaultVAssign;
typedef VendorObject*   SOMLINK somTP_VendorObject_somDefaultConstVAssign(VendorObject *somSelf, 
		som3AssignCtrl* ctrl, 
		SOMObject* fromObj);
typedef somTP_VendorObject_somDefaultConstVAssign *somTD_VendorObject_somDefaultConstVAssign;
typedef void   SOMLINK somTP_VendorObject_somInit(VendorObject *somSelf);
typedef somTP_VendorObject_somInit *somTD_VendorObject_somInit;
typedef void   SOMLINK somTP_VendorObject_somFree(VendorObject *somSelf);
typedef somTP_VendorObject_somFree *somTD_VendorObject_somFree;
typedef void   SOMLINK somTP_VendorObject_somUninit(VendorObject *somSelf);
typedef somTP_VendorObject_somUninit *somTD_VendorObject_somUninit;
typedef SOMClass*   SOMLINK somTP_VendorObject_somGetClass(VendorObject *somSelf);
typedef somTP_VendorObject_somGetClass *somTD_VendorObject_somGetClass;
typedef string   SOMLINK somTP_VendorObject_somGetClassName(VendorObject *somSelf);
typedef somTP_VendorObject_somGetClassName *somTD_VendorObject_somGetClassName;
typedef long   SOMLINK somTP_VendorObject_somGetSize(VendorObject *somSelf);
typedef somTP_VendorObject_somGetSize *somTD_VendorObject_somGetSize;
typedef boolean   SOMLINK somTP_VendorObject_somIsA(VendorObject *somSelf, 
		SOMClass* aClassObj);
typedef somTP_VendorObject_somIsA *somTD_VendorObject_somIsA;
typedef boolean   SOMLINK somTP_VendorObject_somIsInstanceOf(VendorObject *somSelf, 
		SOMClass* aClassObj);
typedef somTP_VendorObject_somIsInstanceOf *somTD_VendorObject_somIsInstanceOf;
typedef boolean   SOMLINK somTP_VendorObject_somRespondsTo(VendorObject *somSelf, 
		somId mId);
typedef somTP_VendorObject_somRespondsTo *somTD_VendorObject_somRespondsTo;
typedef boolean   SOMLINK somTP_VendorObject_somDispatch(VendorObject *somSelf, 
		somToken* retValue, 
		somId methodId, 
		va_list ap);
typedef somTP_VendorObject_somDispatch *somTD_VendorObject_somDispatch;
typedef boolean   SOMLINK somTP_VendorObject_somClassDispatch(VendorObject *somSelf, 
		SOMClass* clsObj, 
		somToken* retValue, 
		somId methodId, 
		va_list ap);
typedef somTP_VendorObject_somClassDispatch *somTD_VendorObject_somClassDispatch;
typedef boolean   SOMLINK somTP_VendorObject_somCastObj(VendorObject *somSelf, 
		SOMClass* cls);
typedef somTP_VendorObject_somCastObj *somTD_VendorObject_somCastObj;
typedef boolean   SOMLINK somTP_VendorObject_somResetObj(VendorObject *somSelf);
typedef somTP_VendorObject_somResetObj *somTD_VendorObject_somResetObj;
typedef void   SOMLINK somTP_VendorObject_somDispatchV(VendorObject *somSelf, 
		somId methodId, 
		somId descriptor, 
		va_list ap);
typedef somTP_VendorObject_somDispatchV *somTD_VendorObject_somDispatchV;
typedef long   SOMLINK somTP_VendorObject_somDispatchL(VendorObject *somSelf, 
		somId methodId, 
		somId descriptor, 
		va_list ap);
typedef somTP_VendorObject_somDispatchL *somTD_VendorObject_somDispatchL;
typedef void*   SOMLINK somTP_VendorObject_somDispatchA(VendorObject *somSelf, 
		somId methodId, 
		somId descriptor, 
		va_list ap);
typedef somTP_VendorObject_somDispatchA *somTD_VendorObject_somDispatchA;
typedef double   SOMLINK somTP_VendorObject_somDispatchD(VendorObject *somSelf, 
		somId methodId, 
		somId descriptor, 
		va_list ap);
typedef somTP_VendorObject_somDispatchD *somTD_VendorObject_somDispatchD;
typedef SOMObject*   SOMLINK somTP_VendorObject_somPrintSelf(VendorObject *somSelf);
typedef somTP_VendorObject_somPrintSelf *somTD_VendorObject_somPrintSelf;
typedef void   SOMLINK somTP_VendorObject_somDumpSelf(VendorObject *somSelf, 
		long level);
typedef somTP_VendorObject_somDumpSelf *somTD_VendorObject_somDumpSelf;
typedef void   SOMLINK somTP_VendorObject_somDumpSelfInt(VendorObject *somSelf, 
		long level);
typedef somTP_VendorObject_somDumpSelfInt *somTD_VendorObject_somDumpSelfInt;
}

#endif /* VendorObject_API */


/*
 * -- This emitter treats Method Tokens as Thunks by default.
 * -- Use the sc modifier "nothunks" to change this default
 */
#undef somresolve_
#define somresolve_(obj,mToken) ((somMethodProc*)((void)obj, mToken))

/*
 * -- The C++ Wrapper Class for VendorObject
 */
class VendorObject : public somf_MCollectible
{
public:

// VendorObject::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 (!_VendorObject) VendorObjectNewClass(VendorObject_MajorVersion,VendorObject_MinorVersion);
   return (void*)
      SOM_Resolve(_VendorObject,SOMClass,somNewNoInit)
         ((SOMClass *)((void*)_VendorObject));
}

// VendorObject::delete uses somDestruct.
void operator delete(void * obj)
{
   if (obj && *(void**)obj) {
      SOM_Resolve(obj,SOMObject,somFree)
         ((SOMObject*)obj);
   }
}

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

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

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

#ifdef __IBMCPP__
#pragma info(nocnv,nopar)
#endif
VendorObject(const VendorObject* fromObj)
{
   if (*(void**)this != 
       ((somParentMtabStructPtr)
        (VendorObjectCClassData.parentMtab))->mtab)
      return;
   ((SOMObject*)((void*)this))->somDefaultConstCopyInit(0,((SOMObject*)((void*)fromObj)));
}
#ifdef __IBMCPP__
#pragma info(restore)
#endif


/* method: _get_vendorName */
string   _get_vendorName(Environment *ev)
{
/*
 * Method from the IDL attribute statement:
 * "attribute string vendorName"
 */
   return SOM_ResolveD(this,VendorObject,VendorObject,_get_vendorName)
	(this, ev);
}


/* method: _set_vendorName */
void   _set_vendorName(Environment *ev, 
		string vendorName)
{
/*
 * Method from the IDL attribute statement:
 * "attribute string vendorName"
 */
   SOM_ResolveD(this,VendorObject,VendorObject,_set_vendorName)
	(this, ev,vendorName);
}


/* method: addProduct */
ProductObject*   addProduct(Environment *ev, 
		long key, 
		string productName)
{
   return SOM_ResolveD(this,VendorObject,VendorObject,addProduct)
	(this, ev,key,productName);
}


/* method: findProduct */
ProductObject*   findProduct(Environment *ev, 
		long key)
{
   return SOM_ResolveD(this,VendorObject,VendorObject,findProduct)
	(this, ev,key);
}


/*
 * Reintroduce inherited methods
 */

/* method: somfClone */
somf_MCollectible*   somfClone(Environment *ev)
{
/*
 *  somfClone provides a general function for creating a new instance of this.
 */
   return SOM_ResolveD(this,VendorObject,somf_MCollectible,somfClone)
	(this, ev);
}


/* method: somfClonePointer */
somf_MCollectible*   somfClonePointer(Environment *ev, 
		somf_MCollectible* clonee)
{
/*
 *  somfClonePointer returns a pointer to a Clone
 */
   return SOM_ResolveD(this,VendorObject,somf_MCollectible,somfClonePointer)
	(this, ev,clonee);
}


/* method: somfHash */
long   somfHash(Environment *ev)
{
/*
 *  somfHash returns a value suitable for use as a hashing probe for this.
 *  The default function will simply return the address of the object.
 *  The default function is almost certainly not adequate if you are overriding
 *  somfIsEqual because you need to make sure that all objects that "are equal"
 *  to each other return the same hash value.  For example, a TText object would
 *  return a hash value computed using the characters in the string instead of
 *  the address of the string.
 */
   return SOM_ResolveD(this,VendorObject,somf_MCollectible,somfHash)
	(this, ev);
}


/* method: somfIsEqual */
boolean   somfIsEqual(Environment *ev, 
		somf_MCollectible* obj)
{
/*
 *  somfIsEqual returns TRUE if obj is isomorphic to this.  The default function
 *  will give you a nasty message.  For example, the somfIsEqual method
 *  for TText objects will do a string comparison.  All of the utility classes
 *  allow you to specify what methods to use when comparing objects for
 *  insertion, deletion, etc.
 */
   return SOM_ResolveD(this,VendorObject,somf_MCollectible,somfIsEqual)
	(this, ev,obj);
}


/* method: somfIsSame */
boolean   somfIsSame(Environment *ev, 
		somf_MCollectible* obj)
{
/*
 *  The default function for somfIsSame is a pointer comparison
 */
   return SOM_ResolveD(this,VendorObject,somf_MCollectible,somfIsSame)
	(this, ev,obj);
}


/* method: somfIsNotEqual */
boolean   somfIsNotEqual(Environment *ev, 
		somf_MCollectible* obj)
{
/*
 *  somfIsNotEqual returns TRUE if obj is NOT isomorphic to this.  It uses
 *  somfIsEqual, so overriding somfIsEqual will handle the logic of somfIsNotEqual too.
 */
   return SOM_ResolveD(this,VendorObject,somf_MCollectible,somfIsNotEqual)
	(this, ev,obj);
}


/* 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_ResolveD(this,VendorObject,SOMObject,somDefaultInit)
	(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_ResolveD(this,VendorObject,SOMObject,somDestruct)
	(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_ResolveD(this,VendorObject,SOMObject,somDefaultCopyInit)
	(this,ctrl,fromObj);
}


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


/* initializer method: somDefaultConstCopyInit */
void   somDefaultConstCopyInit(som3InitCtrl* ctrl, 
		SOMObject* fromObj)
{
/*
 *  A default copy constructor that uses a const fromObj.
 */
   SOM_ResolveD(this,VendorObject,SOMObject,somDefaultConstCopyInit)
	(this,ctrl,fromObj);
}


/* initializer method: somDefaultVCopyInit */
void   somDefaultVCopyInit(som3InitCtrl* ctrl, 
		SOMObject* fromObj)
{
/*
 *  A default copy constructor that uses a volatile fromObj.
 */
   SOM_ResolveD(this,VendorObject,SOMObject,somDefaultVCopyInit)
	(this,ctrl,fromObj);
}


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


/* method: somDefaultConstAssign */
VendorObject*  somDefaultConstAssign(som3AssignCtrl* ctrl, 
		SOMObject* fromObj)
{
/*
 *  A default assignment operator that uses a const fromObj.
 */
   return SOM_ResolveD(this,VendorObject,SOMObject,somDefaultConstAssign)
	(this,ctrl,fromObj);
}


/* method: somDefaultVAssign */
VendorObject*  somDefaultVAssign(som3AssignCtrl* ctrl, 
		SOMObject* fromObj)
{
/*
 *  A default assignment operator that uses a volatile fromObj.
 */
   return SOM_ResolveD(this,VendorObject,SOMObject,somDefaultVAssign)
	(this,ctrl,fromObj);
}


/* method: somDefaultConstVAssign */
VendorObject*  somDefaultConstVAssign(som3AssignCtrl* ctrl, 
		SOMObject* fromObj)
{
/*
 *  A default assignment operator that uses a const volatile fromObj.
 */
   return SOM_ResolveD(this,VendorObject,SOMObject,somDefaultConstVAssign)
	(this,ctrl,fromObj);
}


/* method: somInit */
void   somInit()
{
/*
 *  Obsolete but still supported. Override somDefaultInit instead of somInit.
 */
   SOM_ResolveD(this,VendorObject,SOMObject,somInit)
	(this);
}


/* method: somFree */
void   somFree()
{
/*
 *  Use as directed by framework implementations.
 */
   SOM_ResolveD(this,VendorObject,SOMObject,somFree)
	(this);
}


/* method: somUninit */
void   somUninit()
{
/*
 *  Obsolete but still supported. Override somDestruct instead of somUninit.
 */
   SOM_ResolveD(this,VendorObject,SOMObject,somUninit)
	(this);
}


/* method: somGetClass */
SOMClass*   somGetClass()
{
/*
 *  Return the receiver's class.
 */
   return SOM_ResolveD(this,VendorObject,SOMObject,somGetClass)
	(this);
}


/* method: somGetClassName */
string   somGetClassName()
{
/*
 *  Return the name of the receiver's class.
 */
   return SOM_ResolveD(this,VendorObject,SOMObject,somGetClassName)
	(this);
}


/* method: somGetSize */
long   somGetSize()
{
/*
 *  Return the size of the receiver.
 */
   return SOM_ResolveD(this,VendorObject,SOMObject,somGetSize)
	(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_ResolveD(this,VendorObject,SOMObject,somIsA)
	(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_ResolveD(this,VendorObject,SOMObject,somIsInstanceOf)
	(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_ResolveD(this,VendorObject,SOMObject,somRespondsTo)
	(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.
 */
/* the va_list invocation form */
boolean   VendorObject_somDispatch(somToken* retValue, 
		somId methodId, 
		va_list ap)
{return SOM_ResolveD(this,VendorObject,SOMObject,somDispatch)
	(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.
 */
   va_list ap;
   va_start(ap, methodId);
   boolean __somResult = 
      SOM_ResolveD(this,VendorObject,SOMObject,somDispatch)
	(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   VendorObject_somClassDispatch(SOMClass* clsObj, 
		somToken* retValue, 
		somId methodId, 
		va_list ap)
{return SOM_ResolveD(this,VendorObject,SOMObject,somClassDispatch)
	(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_ResolveD(this,VendorObject,SOMObject,somClassDispatch)
	(this,clsObj,retValue,methodId,ap);
   va_end(ap);
   return __somResult;
}


/* method: somCastObj */
boolean   somCastObj(SOMClass* cls)
{
/*
 *  cast the receiving object to cls (which must be an ancestor of the
 *  objects true class. Returns true on success.
 */
   return SOM_ResolveD(this,VendorObject,SOMObject,somCastObj)
	(this,cls);
}


/* method: somResetObj */
boolean   somResetObj()
{
/*
 *  reset an object to its true class. Returns true always.
 */
   return SOM_ResolveD(this,VendorObject,SOMObject,somResetObj)
	(this);
}


/* va_list method: somDispatchV */

/*
 *  Obsolete. Use somDispatch instead.
 */
/* the va_list invocation form */
void   VendorObject_somDispatchV(somId methodId, 
		somId descriptor, 
		va_list ap)
{   SOM_ResolveD(this,VendorObject,SOMObject,somDispatchV)
	(this,methodId,descriptor,ap);
}

/* the varargs invocation form */
void   somDispatchV(somId methodId, 
		somId descriptor, 
		...)
{
/*
 *  Obsolete. Use somDispatch instead.
 */
   va_list ap;
   va_start(ap, descriptor);
   SOM_ResolveD(this,VendorObject,SOMObject,somDispatchV)
	(this,methodId,descriptor,ap);
   va_end(ap);
}


/* va_list method: somDispatchL */

/*
 *  Obsolete. Use somDispatch instead.
 */
/* the va_list invocation form */
long   VendorObject_somDispatchL(somId methodId, 
		somId descriptor, 
		va_list ap)
{return SOM_ResolveD(this,VendorObject,SOMObject,somDispatchL)
	(this,methodId,descriptor,ap);
}

/* the varargs invocation form */
long   somDispatchL(somId methodId, 
		somId descriptor, 
		...)
{
/*
 *  Obsolete. Use somDispatch instead.
 */
   va_list ap;
   va_start(ap, descriptor);
   long __somResult = 
      SOM_ResolveD(this,VendorObject,SOMObject,somDispatchL)
	(this,methodId,descriptor,ap);
   va_end(ap);
   return __somResult;
}


/* va_list method: somDispatchA */

/*
 *  Obsolete. Use somDispatch instead.
 */
/* the va_list invocation form */
void*   VendorObject_somDispatchA(somId methodId, 
		somId descriptor, 
		va_list ap)
{return SOM_ResolveD(this,VendorObject,SOMObject,somDispatchA)
	(this,methodId,descriptor,ap);
}

/* the varargs invocation form */
void*   somDispatchA(somId methodId, 
		somId descriptor, 
		...)
{
/*
 *  Obsolete. Use somDispatch instead.
 */
   va_list ap;
   va_start(ap, descriptor);
   void* __somResult = 
      SOM_ResolveD(this,VendorObject,SOMObject,somDispatchA)
	(this,methodId,descriptor,ap);
   va_end(ap);
   return __somResult;
}


/* va_list method: somDispatchD */

/*
 *  Obsolete. Use somDispatch instead.
 */
/* the va_list invocation form */
double   VendorObject_somDispatchD(somId methodId, 
		somId descriptor, 
		va_list ap)
{return SOM_ResolveD(this,VendorObject,SOMObject,somDispatchD)
	(this,methodId,descriptor,ap);
}

/* the varargs invocation form */
double   somDispatchD(somId methodId, 
		somId descriptor, 
		...)
{
/*
 *  Obsolete. Use somDispatch instead.
 */
   va_list ap;
   va_start(ap, descriptor);
   double __somResult = 
      SOM_ResolveD(this,VendorObject,SOMObject,somDispatchD)
	(this,methodId,descriptor,ap);
   va_end(ap);
   return __somResult;
}


/* method: somPrintSelf */
SOMObject*   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_ResolveD(this,VendorObject,SOMObject,somPrintSelf)
	(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_ResolveD(this,VendorObject,SOMObject,somDumpSelf)
	(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_ResolveD(this,VendorObject,SOMObject,somDumpSelfInt)
	(this,level);
}



};   /* VendorObject */



#endif       /* SOM_VendorObject_xh */

#ifndef SOM_USBDeviceCollection_xh
#define SOM_USBDeviceCollection_xh

class USBDeviceCollection;

#define USBDeviceCollection_MajorVersion 2
#define USBDeviceCollection_MinorVersion 1

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

/* C++ parent defs */
#ifndef SOM_somf_THashTable_xh
#include <thash.xh>
#endif

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

/*
 * Start of bindings for IDL types
 */


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

/* A procedure to create the USBDeviceCollection Class */
SOMEXTERN SOMClass * SOMLINK USBDeviceCollectionNewClass(
		integer4 majorVersion,
		integer4 minorVersion);

/* The API to the USBDeviceCollection class object, and the methods it introduces. */
SOMEXTERN struct USBDeviceCollectionClassDataStructure {
	SOMClass *classObject;
	somMToken addVendor;
	somMToken findVendor;
} SOMDLINK USBDeviceCollectionClassData;
#define _USBDeviceCollection USBDeviceCollectionClassData.classObject

/* The API to parentMtabs for USBDeviceCollection, and the instance data it introduces. */
SOMEXTERN struct USBDeviceCollectionCClassDataStructure {
	somMethodTabs parentMtab;
	somDToken              instanceDataToken;
} SOMDLINK USBDeviceCollectionCClassData;

/*
 * -- Typedefs for USBDeviceCollection Method Procedures
 */
SOMEXTERN {
typedef VendorObject*   SOMLINK somTP_USBDeviceCollection_addVendor(USBDeviceCollection *somSelf, Environment *ev, 
		long key, 
		string vendorName);
typedef somTP_USBDeviceCollection_addVendor *somTD_USBDeviceCollection_addVendor;
typedef VendorObject*   SOMLINK somTP_USBDeviceCollection_findVendor(USBDeviceCollection *somSelf, Environment *ev, 
		long key);
typedef somTP_USBDeviceCollection_findVendor *somTD_USBDeviceCollection_findVendor;

/*
 * -- Typedefs for Reintroduced Wrapper Methods
 */
typedef somf_THashTable*   SOMLINK somTP_USBDeviceCollection_somfTHashTableInitFLLL(USBDeviceCollection *somSelf, Environment *ev, 
		somf_MCollectible_somf_MCollectibleCompareFn testfn, 
		long tablesize, 
		long rate, 
		long threshold);
typedef somTP_USBDeviceCollection_somfTHashTableInitFLLL *somTD_USBDeviceCollection_somfTHashTableInitFLLL;
typedef somf_THashTable*   SOMLINK somTP_USBDeviceCollection_somfTHashTableInitFLL(USBDeviceCollection *somSelf, Environment *ev, 
		somf_MCollectible_somf_MCollectibleCompareFn testfn, 
		long tablesize, 
		long rate);
typedef somTP_USBDeviceCollection_somfTHashTableInitFLL *somTD_USBDeviceCollection_somfTHashTableInitFLL;
typedef somf_THashTable*   SOMLINK somTP_USBDeviceCollection_somfTHashTableInitFL(USBDeviceCollection *somSelf, Environment *ev, 
		somf_MCollectible_somf_MCollectibleCompareFn testfn, 
		long tablesize);
typedef somTP_USBDeviceCollection_somfTHashTableInitFL *somTD_USBDeviceCollection_somfTHashTableInitFL;
typedef somf_THashTable*   SOMLINK somTP_USBDeviceCollection_somfTHashTableInitH(USBDeviceCollection *somSelf, Environment *ev, 
		somf_THashTable* h);
typedef somTP_USBDeviceCollection_somfTHashTableInitH *somTD_USBDeviceCollection_somfTHashTableInitH;
typedef void   SOMLINK somTP_USBDeviceCollection_somfAssign(USBDeviceCollection *somSelf, Environment *ev, 
		somf_THashTable* source);
typedef somTP_USBDeviceCollection_somfAssign *somTD_USBDeviceCollection_somfAssign;
typedef long   SOMLINK somTP_USBDeviceCollection_somfCount(USBDeviceCollection *somSelf, Environment *ev);
typedef somTP_USBDeviceCollection_somfCount *somTD_USBDeviceCollection_somfCount;
typedef somf_MCollectible*   SOMLINK somTP_USBDeviceCollection_somfRemove(USBDeviceCollection *somSelf, Environment *ev, 
		somf_MCollectible* key);
typedef somTP_USBDeviceCollection_somfRemove *somTD_USBDeviceCollection_somfRemove;
typedef somf_MCollectible*   SOMLINK somTP_USBDeviceCollection_somfDelete(USBDeviceCollection *somSelf, Environment *ev, 
		somf_MCollectible* key);
typedef somTP_USBDeviceCollection_somfDelete *somTD_USBDeviceCollection_somfDelete;
typedef somf_MCollectible*   SOMLINK somTP_USBDeviceCollection_somfMember(USBDeviceCollection *somSelf, Environment *ev, 
		somf_MCollectible* key);
typedef somTP_USBDeviceCollection_somfMember *somTD_USBDeviceCollection_somfMember;
typedef void   SOMLINK somTP_USBDeviceCollection_somfRemoveAll(USBDeviceCollection *somSelf, Environment *ev);
typedef somTP_USBDeviceCollection_somfRemoveAll *somTD_USBDeviceCollection_somfRemoveAll;
typedef void   SOMLINK somTP_USBDeviceCollection_somfDeleteAll(USBDeviceCollection *somSelf, Environment *ev);
typedef somTP_USBDeviceCollection_somfDeleteAll *somTD_USBDeviceCollection_somfDeleteAll;
typedef void   SOMLINK somTP_USBDeviceCollection_somfDeleteAllKeys(USBDeviceCollection *somSelf, Environment *ev);
typedef somTP_USBDeviceCollection_somfDeleteAllKeys *somTD_USBDeviceCollection_somfDeleteAllKeys;
typedef void   SOMLINK somTP_USBDeviceCollection_somfDeleteAllValues(USBDeviceCollection *somSelf, Environment *ev);
typedef somTP_USBDeviceCollection_somfDeleteAllValues *somTD_USBDeviceCollection_somfDeleteAllValues;
typedef somf_MCollectible*   SOMLINK somTP_USBDeviceCollection_somfAddMMB(USBDeviceCollection *somSelf, Environment *ev, 
		somf_MCollectible* key, 
		somf_MCollectible* value, 
		boolean replace);
typedef somTP_USBDeviceCollection_somfAddMMB *somTD_USBDeviceCollection_somfAddMMB;
typedef somf_MCollectible*   SOMLINK somTP_USBDeviceCollection_somfAddMM(USBDeviceCollection *somSelf, Environment *ev, 
		somf_MCollectible* key, 
		somf_MCollectible* value);
typedef somTP_USBDeviceCollection_somfAddMM *somTD_USBDeviceCollection_somfAddMM;
typedef void   SOMLINK somTP_USBDeviceCollection_somfGrow(USBDeviceCollection *somSelf, Environment *ev);
typedef somTP_USBDeviceCollection_somfGrow *somTD_USBDeviceCollection_somfGrow;
typedef somf_MCollectible*   SOMLINK somTP_USBDeviceCollection_somfRetrieve(USBDeviceCollection *somSelf, Environment *ev, 
		somf_MCollectible* key);
typedef somTP_USBDeviceCollection_somfRetrieve *somTD_USBDeviceCollection_somfRetrieve;
typedef void   SOMLINK somTP_USBDeviceCollection_somfSetGrowthRate(USBDeviceCollection *somSelf, Environment *ev, 
		long rate);
typedef somTP_USBDeviceCollection_somfSetGrowthRate *somTD_USBDeviceCollection_somfSetGrowthRate;
typedef void   SOMLINK somTP_USBDeviceCollection_somfSetRehashThreshold(USBDeviceCollection *somSelf, Environment *ev, 
		long threshold);
typedef somTP_USBDeviceCollection_somfSetRehashThreshold *somTD_USBDeviceCollection_somfSetRehashThreshold;
typedef long   SOMLINK somTP_USBDeviceCollection_somfGetGrowthRate(USBDeviceCollection *somSelf, Environment *ev);
typedef somTP_USBDeviceCollection_somfGetGrowthRate *somTD_USBDeviceCollection_somfGetGrowthRate;
typedef long   SOMLINK somTP_USBDeviceCollection_somfGetRehashThreshold(USBDeviceCollection *somSelf, Environment *ev);
typedef somTP_USBDeviceCollection_somfGetRehashThreshold *somTD_USBDeviceCollection_somfGetRehashThreshold;
typedef void   SOMLINK somTP_USBDeviceCollection_somfSetHashFunction(USBDeviceCollection *somSelf, Environment *ev, 
		somf_MCollectible_somf_MCollectibleHashFn fn);
typedef somTP_USBDeviceCollection_somfSetHashFunction *somTD_USBDeviceCollection_somfSetHashFunction;
typedef somf_MCollectible_somf_MCollectibleHashFn   SOMLINK somTP_USBDeviceCollection_somfGetHashFunction(USBDeviceCollection *somSelf, Environment *ev);
typedef somTP_USBDeviceCollection_somfGetHashFunction *somTD_USBDeviceCollection_somfGetHashFunction;
typedef void   SOMLINK somTP_USBDeviceCollection_somInit(USBDeviceCollection *somSelf);
typedef somTP_USBDeviceCollection_somInit *somTD_USBDeviceCollection_somInit;
typedef void   SOMLINK somTP_USBDeviceCollection_somUninit(USBDeviceCollection *somSelf);
typedef somTP_USBDeviceCollection_somUninit *somTD_USBDeviceCollection_somUninit;
typedef somf_MCollectible*   SOMLINK somTP_USBDeviceCollection_somfClone(USBDeviceCollection *somSelf, Environment *ev);
typedef somTP_USBDeviceCollection_somfClone *somTD_USBDeviceCollection_somfClone;
typedef somf_MCollectible*   SOMLINK somTP_USBDeviceCollection_somfClonePointer(USBDeviceCollection *somSelf, Environment *ev, 
		somf_MCollectible* clonee);
typedef somTP_USBDeviceCollection_somfClonePointer *somTD_USBDeviceCollection_somfClonePointer;
typedef long   SOMLINK somTP_USBDeviceCollection_somfHash(USBDeviceCollection *somSelf, Environment *ev);
typedef somTP_USBDeviceCollection_somfHash *somTD_USBDeviceCollection_somfHash;
typedef boolean   SOMLINK somTP_USBDeviceCollection_somfIsEqual(USBDeviceCollection *somSelf, Environment *ev, 
		somf_MCollectible* obj);
typedef somTP_USBDeviceCollection_somfIsEqual *somTD_USBDeviceCollection_somfIsEqual;
typedef boolean   SOMLINK somTP_USBDeviceCollection_somfIsSame(USBDeviceCollection *somSelf, Environment *ev, 
		somf_MCollectible* obj);
typedef somTP_USBDeviceCollection_somfIsSame *somTD_USBDeviceCollection_somfIsSame;
typedef boolean   SOMLINK somTP_USBDeviceCollection_somfIsNotEqual(USBDeviceCollection *somSelf, Environment *ev, 
		somf_MCollectible* obj);
typedef somTP_USBDeviceCollection_somfIsNotEqual *somTD_USBDeviceCollection_somfIsNotEqual;
typedef void   SOMLINK somTP_USBDeviceCollection_somDefaultInit(USBDeviceCollection *somSelf, 
		som3InitCtrl* ctrl);
typedef somTP_USBDeviceCollection_somDefaultInit *somTD_USBDeviceCollection_somDefaultInit;
typedef void   SOMLINK somTP_USBDeviceCollection_somDestruct(USBDeviceCollection *somSelf, 
		octet doFree, 
		som3DestructCtrl* ctrl);
typedef somTP_USBDeviceCollection_somDestruct *somTD_USBDeviceCollection_somDestruct;
typedef void   SOMLINK somTP_USBDeviceCollection_somDefaultCopyInit(USBDeviceCollection *somSelf, 
		som3InitCtrl* ctrl, 
		SOMObject* fromObj);
typedef somTP_USBDeviceCollection_somDefaultCopyInit *somTD_USBDeviceCollection_somDefaultCopyInit;
typedef USBDeviceCollection*   SOMLINK somTP_USBDeviceCollection_somDefaultAssign(USBDeviceCollection *somSelf, 
		som3AssignCtrl* ctrl, 
		SOMObject* fromObj);
typedef somTP_USBDeviceCollection_somDefaultAssign *somTD_USBDeviceCollection_somDefaultAssign;
typedef void   SOMLINK somTP_USBDeviceCollection_somDefaultConstCopyInit(USBDeviceCollection *somSelf, 
		som3InitCtrl* ctrl, 
		SOMObject* fromObj);
typedef somTP_USBDeviceCollection_somDefaultConstCopyInit *somTD_USBDeviceCollection_somDefaultConstCopyInit;
typedef void   SOMLINK somTP_USBDeviceCollection_somDefaultVCopyInit(USBDeviceCollection *somSelf, 
		som3InitCtrl* ctrl, 
		SOMObject* fromObj);
typedef somTP_USBDeviceCollection_somDefaultVCopyInit *somTD_USBDeviceCollection_somDefaultVCopyInit;
typedef void   SOMLINK somTP_USBDeviceCollection_somDefaultConstVCopyInit(USBDeviceCollection *somSelf, 
		som3InitCtrl* ctrl, 
		SOMObject* fromObj);
typedef somTP_USBDeviceCollection_somDefaultConstVCopyInit *somTD_USBDeviceCollection_somDefaultConstVCopyInit;
typedef USBDeviceCollection*   SOMLINK somTP_USBDeviceCollection_somDefaultConstAssign(USBDeviceCollection *somSelf, 
		som3AssignCtrl* ctrl, 
		SOMObject* fromObj);
typedef somTP_USBDeviceCollection_somDefaultConstAssign *somTD_USBDeviceCollection_somDefaultConstAssign;
typedef USBDeviceCollection*   SOMLINK somTP_USBDeviceCollection_somDefaultVAssign(USBDeviceCollection *somSelf, 
		som3AssignCtrl* ctrl, 
		SOMObject* fromObj);
typedef somTP_USBDeviceCollection_somDefaultVAssign *somTD_USBDeviceCollection_somDefaultVAssign;
typedef USBDeviceCollection*   SOMLINK somTP_USBDeviceCollection_somDefaultConstVAssign(USBDeviceCollection *somSelf, 
		som3AssignCtrl* ctrl, 
		SOMObject* fromObj);
typedef somTP_USBDeviceCollection_somDefaultConstVAssign *somTD_USBDeviceCollection_somDefaultConstVAssign;
typedef void   SOMLINK somTP_USBDeviceCollection_somFree(USBDeviceCollection *somSelf);
typedef somTP_USBDeviceCollection_somFree *somTD_USBDeviceCollection_somFree;
typedef SOMClass*   SOMLINK somTP_USBDeviceCollection_somGetClass(USBDeviceCollection *somSelf);
typedef somTP_USBDeviceCollection_somGetClass *somTD_USBDeviceCollection_somGetClass;
typedef string   SOMLINK somTP_USBDeviceCollection_somGetClassName(USBDeviceCollection *somSelf);
typedef somTP_USBDeviceCollection_somGetClassName *somTD_USBDeviceCollection_somGetClassName;
typedef long   SOMLINK somTP_USBDeviceCollection_somGetSize(USBDeviceCollection *somSelf);
typedef somTP_USBDeviceCollection_somGetSize *somTD_USBDeviceCollection_somGetSize;
typedef boolean   SOMLINK somTP_USBDeviceCollection_somIsA(USBDeviceCollection *somSelf, 
		SOMClass* aClassObj);
typedef somTP_USBDeviceCollection_somIsA *somTD_USBDeviceCollection_somIsA;
typedef boolean   SOMLINK somTP_USBDeviceCollection_somIsInstanceOf(USBDeviceCollection *somSelf, 
		SOMClass* aClassObj);
typedef somTP_USBDeviceCollection_somIsInstanceOf *somTD_USBDeviceCollection_somIsInstanceOf;
typedef boolean   SOMLINK somTP_USBDeviceCollection_somRespondsTo(USBDeviceCollection *somSelf, 
		somId mId);
typedef somTP_USBDeviceCollection_somRespondsTo *somTD_USBDeviceCollection_somRespondsTo;
typedef boolean   SOMLINK somTP_USBDeviceCollection_somDispatch(USBDeviceCollection *somSelf, 
		somToken* retValue, 
		somId methodId, 
		va_list ap);
typedef somTP_USBDeviceCollection_somDispatch *somTD_USBDeviceCollection_somDispatch;
typedef boolean   SOMLINK somTP_USBDeviceCollection_somClassDispatch(USBDeviceCollection *somSelf, 
		SOMClass* clsObj, 
		somToken* retValue, 
		somId methodId, 
		va_list ap);
typedef somTP_USBDeviceCollection_somClassDispatch *somTD_USBDeviceCollection_somClassDispatch;
typedef boolean   SOMLINK somTP_USBDeviceCollection_somCastObj(USBDeviceCollection *somSelf, 
		SOMClass* cls);
typedef somTP_USBDeviceCollection_somCastObj *somTD_USBDeviceCollection_somCastObj;
typedef boolean   SOMLINK somTP_USBDeviceCollection_somResetObj(USBDeviceCollection *somSelf);
typedef somTP_USBDeviceCollection_somResetObj *somTD_USBDeviceCollection_somResetObj;
typedef void   SOMLINK somTP_USBDeviceCollection_somDispatchV(USBDeviceCollection *somSelf, 
		somId methodId, 
		somId descriptor, 
		va_list ap);
typedef somTP_USBDeviceCollection_somDispatchV *somTD_USBDeviceCollection_somDispatchV;
typedef long   SOMLINK somTP_USBDeviceCollection_somDispatchL(USBDeviceCollection *somSelf, 
		somId methodId, 
		somId descriptor, 
		va_list ap);
typedef somTP_USBDeviceCollection_somDispatchL *somTD_USBDeviceCollection_somDispatchL;
typedef void*   SOMLINK somTP_USBDeviceCollection_somDispatchA(USBDeviceCollection *somSelf, 
		somId methodId, 
		somId descriptor, 
		va_list ap);
typedef somTP_USBDeviceCollection_somDispatchA *somTD_USBDeviceCollection_somDispatchA;
typedef double   SOMLINK somTP_USBDeviceCollection_somDispatchD(USBDeviceCollection *somSelf, 
		somId methodId, 
		somId descriptor, 
		va_list ap);
typedef somTP_USBDeviceCollection_somDispatchD *somTD_USBDeviceCollection_somDispatchD;
typedef SOMObject*   SOMLINK somTP_USBDeviceCollection_somPrintSelf(USBDeviceCollection *somSelf);
typedef somTP_USBDeviceCollection_somPrintSelf *somTD_USBDeviceCollection_somPrintSelf;
typedef void   SOMLINK somTP_USBDeviceCollection_somDumpSelf(USBDeviceCollection *somSelf, 
		long level);
typedef somTP_USBDeviceCollection_somDumpSelf *somTD_USBDeviceCollection_somDumpSelf;
typedef void   SOMLINK somTP_USBDeviceCollection_somDumpSelfInt(USBDeviceCollection *somSelf, 
		long level);
typedef somTP_USBDeviceCollection_somDumpSelfInt *somTD_USBDeviceCollection_somDumpSelfInt;
}

#endif /* USBDeviceCollection_API */


/*
 * -- This emitter treats Method Tokens as Thunks by default.
 * -- Use the sc modifier "nothunks" to change this default
 */
#undef somresolve_
#define somresolve_(obj,mToken) ((somMethodProc*)((void)obj, mToken))

/*
 * -- The C++ Wrapper Class for USBDeviceCollection
 */
class USBDeviceCollection : public somf_THashTable
{
public:

// USBDeviceCollection::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 (!_USBDeviceCollection) USBDeviceCollectionNewClass(USBDeviceCollection_MajorVersion,USBDeviceCollection_MinorVersion);
   return (void*)
      SOM_Resolve(_USBDeviceCollection,SOMClass,somNewNoInit)
         ((SOMClass *)((void*)_USBDeviceCollection));
}

// USBDeviceCollection::delete uses somDestruct.
void operator delete(void * obj)
{
   if (obj && *(void**)obj) {
      SOM_Resolve(obj,SOMObject,somFree)
         ((SOMObject*)obj);
   }
}

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

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

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

#ifdef __IBMCPP__
#pragma info(nocnv,nopar)
#endif
USBDeviceCollection(const USBDeviceCollection* fromObj)
{
   if (*(void**)this != 
       ((somParentMtabStructPtr)
        (USBDeviceCollectionCClassData.parentMtab))->mtab)
      return;
   ((SOMObject*)((void*)this))->somDefaultConstCopyInit(0,((SOMObject*)((void*)fromObj)));
}
#ifdef __IBMCPP__
#pragma info(restore)
#endif


/* method: addVendor */
VendorObject*   addVendor(Environment *ev, 
		long key, 
		string vendorName)
{
   return SOM_ResolveD(this,USBDeviceCollection,USBDeviceCollection,addVendor)
	(this, ev,key,vendorName);
}


/* method: findVendor */
VendorObject*   findVendor(Environment *ev, 
		long key)
{
   return SOM_ResolveD(this,USBDeviceCollection,USBDeviceCollection,findVendor)
	(this, ev,key);
}


/*
 * Reintroduce inherited methods
 */

/* method: somfTHashTableInitFLLL */
somf_THashTable*   somfTHashTableInitFLLL(Environment *ev, 
		somf_MCollectible_somf_MCollectibleCompareFn testfn, 
		long tablesize, 
		long rate, 
		long threshold)
{
/*
 *  Initializes the new hash table.
 */
   return SOM_ResolveD(this,USBDeviceCollection,somf_THashTable,somfTHashTableInitFLLL)
	(this, ev,testfn,tablesize,rate,threshold);
}


/* method: somfTHashTableInitFLL */
somf_THashTable*   somfTHashTableInitFLL(Environment *ev, 
		somf_MCollectible_somf_MCollectibleCompareFn testfn, 
		long tablesize, 
		long rate)
{
/*
 *  Initializes the new hash table.
 */
   return SOM_ResolveD(this,USBDeviceCollection,somf_THashTable,somfTHashTableInitFLL)
	(this, ev,testfn,tablesize,rate);
}


/* method: somfTHashTableInitFL */
somf_THashTable*   somfTHashTableInitFL(Environment *ev, 
		somf_MCollectible_somf_MCollectibleCompareFn testfn, 
		long tablesize)
{
/*
 *  Initializes the new hash table.
 */
   return SOM_ResolveD(this,USBDeviceCollection,somf_THashTable,somfTHashTableInitFL)
	(this, ev,testfn,tablesize);
}


/* method: somfTHashTableInitH */
somf_THashTable*   somfTHashTableInitH(Environment *ev, 
		somf_THashTable* h)
{
/*
 *  Initializes the new hash table.
 */
   return SOM_ResolveD(this,USBDeviceCollection,somf_THashTable,somfTHashTableInitH)
	(this, ev,h);
}


/* method: somfAssign */
void   somfAssign(Environment *ev, 
		somf_THashTable* source)
{
/*
 *  Assign the instance of this equal to the instance of source.
 */
   SOM_ResolveD(this,USBDeviceCollection,somf_THashTable,somfAssign)
	(this, ev,source);
}


/* method: somfCount */
long   somfCount(Environment *ev)
{
/*
 *  Return the number of objects in this.
 */
   return SOM_ResolveD(this,USBDeviceCollection,somf_THashTable,somfCount)
	(this, ev);
}


/* method: somfRemove */
somf_MCollectible*   somfRemove(Environment *ev, 
		somf_MCollectible* key)
{
/*
 *  Remove obj from this.  Return the object which was actually removed
 *  (which if you are using an IsSame test function may not be the same
 *  as the object passed in only "equal").
 */
   return SOM_ResolveD(this,USBDeviceCollection,somf_THashTable,somfRemove)
	(this, ev,key);
}


/* method: somfDelete */
somf_MCollectible*   somfDelete(Environment *ev, 
		somf_MCollectible* key)
{
/*
 *  Remove key from this and deallocate the storage that these objects might
 *  have owned (that is, the destructor function is called for each object
 *  in the collection).  Return the object which was actually removed (which
 *  if you are using an IsSame test function may not be the same as the object
 *  passed in only "equal").
 */
   return SOM_ResolveD(this,USBDeviceCollection,somf_THashTable,somfDelete)
	(this, ev,key);
}


/* method: somfMember */
somf_MCollectible*   somfMember(Environment *ev, 
		somf_MCollectible* key)
{
/*
 *  Each object in this is compared to obj using the function testFn.  Return the
 *  object for which testFn returned TRUE.  Return SOMF_NIL if not object was found.
 */
   return SOM_ResolveD(this,USBDeviceCollection,somf_THashTable,somfMember)
	(this, ev,key);
}


/* method: somfRemoveAll */
void   somfRemoveAll(Environment *ev)
{
/*
 *  Remove all of the objects from this.
 */
   SOM_ResolveD(this,USBDeviceCollection,somf_THashTable,somfRemoveAll)
	(this, ev);
}


/* method: somfDeleteAll */
void   somfDeleteAll(Environment *ev)
{
/*
 *  Remove all of the objects from this and deallocate the storage that these
 *  objects might have owned (that is, the destructor function is called
 *  for each object in the collection).
 */
   SOM_ResolveD(this,USBDeviceCollection,somf_THashTable,somfDeleteAll)
	(this, ev);
}


/* method: somfDeleteAllKeys */
void   somfDeleteAllKeys(Environment *ev)
{
/*
 *  Remove all of the keys from this and deallocate the storage that these
 *  objects might have owned (that is, the destructor function is called
 *  for each object in the collection).
 */
   SOM_ResolveD(this,USBDeviceCollection,somf_THashTable,somfDeleteAllKeys)
	(this, ev);
}


/* method: somfDeleteAllValues */
void   somfDeleteAllValues(Environment *ev)
{
/*
 *  Remove all of the values from this and deallocate the storage that these
 *  objects might have owned (that is, the destructor function is called
 *  for each object in the collection).
 */
   SOM_ResolveD(this,USBDeviceCollection,somf_THashTable,somfDeleteAllValues)
	(this, ev);
}


/* method: somfAddMMB */
somf_MCollectible*   somfAddMMB(Environment *ev, 
		somf_MCollectible* key, 
		somf_MCollectible* value, 
		boolean replace)
{
/*
 *  Add key and value to this.  If replace = TRUE, replace a copy if it already
 *  exists.
 */
   return SOM_ResolveD(this,USBDeviceCollection,somf_THashTable,somfAddMMB)
	(this, ev,key,value,replace);
}


/* method: somfAddMM */
somf_MCollectible*   somfAddMM(Environment *ev, 
		somf_MCollectible* key, 
		somf_MCollectible* value)
{
/*
 *  Add key and value to this.  Replace a copy if it already exists.
 */
   return SOM_ResolveD(this,USBDeviceCollection,somf_THashTable,somfAddMM)
	(this, ev,key,value);
}


/* method: somfGrow */
void   somfGrow(Environment *ev)
{
/*
 *  Grow the Hash Table
 */
   SOM_ResolveD(this,USBDeviceCollection,somf_THashTable,somfGrow)
	(this, ev);
}


/* method: somfRetrieve */
somf_MCollectible*   somfRetrieve(Environment *ev, 
		somf_MCollectible* key)
{
/*
 *  Retrieve and return the value associated with key.
 */
   return SOM_ResolveD(this,USBDeviceCollection,somf_THashTable,somfRetrieve)
	(this, ev,key);
}


/* method: somfSetGrowthRate */
void   somfSetGrowthRate(Environment *ev, 
		long rate)
{
/*
 *  Set the growth rate of the hash table.
 */
   SOM_ResolveD(this,USBDeviceCollection,somf_THashTable,somfSetGrowthRate)
	(this, ev,rate);
}


/* method: somfSetRehashThreshold */
void   somfSetRehashThreshold(Environment *ev, 
		long threshold)
{
/*
 *  Set the rehash threshold of the hash table.
 */
   SOM_ResolveD(this,USBDeviceCollection,somf_THashTable,somfSetRehashThreshold)
	(this, ev,threshold);
}


/* method: somfGetGrowthRate */
long   somfGetGrowthRate(Environment *ev)
{
/*
 *  Return the growth rate of the hash table.
 */
   return SOM_ResolveD(this,USBDeviceCollection,somf_THashTable,somfGetGrowthRate)
	(this, ev);
}


/* method: somfGetRehashThreshold */
long   somfGetRehashThreshold(Environment *ev)
{
/*
 *  Return the rehash threshold of the hash table.
 */
   return SOM_ResolveD(this,USBDeviceCollection,somf_THashTable,somfGetRehashThreshold)
	(this, ev);
}


/* method: somfSetHashFunction */
void   somfSetHashFunction(Environment *ev, 
		somf_MCollectible_somf_MCollectibleHashFn fn)
{
/*
 *  Set the hash function to fn.
 */
   SOM_ResolveD(this,USBDeviceCollection,somf_THashTable,somfSetHashFunction)
	(this, ev,fn);
}


/* method: somfGetHashFunction */
somf_MCollectible_somf_MCollectibleHashFn   somfGetHashFunction(Environment *ev)
{
/*
 *  Return the hash function.
 */
   return SOM_ResolveD(this,USBDeviceCollection,somf_THashTable,somfGetHashFunction)
	(this, ev);
}


/* method: somInit */
void   somInit()
{
   SOM_ResolveD(this,USBDeviceCollection,SOMObject,somInit)
	(this);
}


/* method: somUninit */
void   somUninit()
{
   SOM_ResolveD(this,USBDeviceCollection,SOMObject,somUninit)
	(this);
}


/* method: somfClone */
somf_MCollectible*   somfClone(Environment *ev)
{
/*
 *  somfClone provides a general function for creating a new instance of this.
 */
   return SOM_ResolveD(this,USBDeviceCollection,somf_MCollectible,somfClone)
	(this, ev);
}


/* method: somfClonePointer */
somf_MCollectible*   somfClonePointer(Environment *ev, 
		somf_MCollectible* clonee)
{
/*
 *  somfClonePointer returns a pointer to a Clone
 */
   return SOM_ResolveD(this,USBDeviceCollection,somf_MCollectible,somfClonePointer)
	(this, ev,clonee);
}


/* method: somfHash */
long   somfHash(Environment *ev)
{
/*
 *  somfHash returns a value suitable for use as a hashing probe for this.
 *  The default function will simply return the address of the object.
 *  The default function is almost certainly not adequate if you are overriding
 *  somfIsEqual because you need to make sure that all objects that "are equal"
 *  to each other return the same hash value.  For example, a TText object would
 *  return a hash value computed using the characters in the string instead of
 *  the address of the string.
 */
   return SOM_ResolveD(this,USBDeviceCollection,somf_MCollectible,somfHash)
	(this, ev);
}


/* method: somfIsEqual */
boolean   somfIsEqual(Environment *ev, 
		somf_MCollectible* obj)
{
/*
 *  somfIsEqual returns TRUE if obj is isomorphic to this.  The default function
 *  will give you a nasty message.  For example, the somfIsEqual method
 *  for TText objects will do a string comparison.  All of the utility classes
 *  allow you to specify what methods to use when comparing objects for
 *  insertion, deletion, etc.
 */
   return SOM_ResolveD(this,USBDeviceCollection,somf_MCollectible,somfIsEqual)
	(this, ev,obj);
}


/* method: somfIsSame */
boolean   somfIsSame(Environment *ev, 
		somf_MCollectible* obj)
{
/*
 *  The default function for somfIsSame is a pointer comparison
 */
   return SOM_ResolveD(this,USBDeviceCollection,somf_MCollectible,somfIsSame)
	(this, ev,obj);
}


/* method: somfIsNotEqual */
boolean   somfIsNotEqual(Environment *ev, 
		somf_MCollectible* obj)
{
/*
 *  somfIsNotEqual returns TRUE if obj is NOT isomorphic to this.  It uses
 *  somfIsEqual, so overriding somfIsEqual will handle the logic of somfIsNotEqual too.
 */
   return SOM_ResolveD(this,USBDeviceCollection,somf_MCollectible,somfIsNotEqual)
	(this, ev,obj);
}


/* 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_ResolveD(this,USBDeviceCollection,SOMObject,somDefaultInit)
	(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_ResolveD(this,USBDeviceCollection,SOMObject,somDestruct)
	(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_ResolveD(this,USBDeviceCollection,SOMObject,somDefaultCopyInit)
	(this,ctrl,fromObj);
}


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


/* initializer method: somDefaultConstCopyInit */
void   somDefaultConstCopyInit(som3InitCtrl* ctrl, 
		SOMObject* fromObj)
{
/*
 *  A default copy constructor that uses a const fromObj.
 */
   SOM_ResolveD(this,USBDeviceCollection,SOMObject,somDefaultConstCopyInit)
	(this,ctrl,fromObj);
}


/* initializer method: somDefaultVCopyInit */
void   somDefaultVCopyInit(som3InitCtrl* ctrl, 
		SOMObject* fromObj)
{
/*
 *  A default copy constructor that uses a volatile fromObj.
 */
   SOM_ResolveD(this,USBDeviceCollection,SOMObject,somDefaultVCopyInit)
	(this,ctrl,fromObj);
}


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


/* method: somDefaultConstAssign */
USBDeviceCollection*  somDefaultConstAssign(som3AssignCtrl* ctrl, 
		SOMObject* fromObj)
{
/*
 *  A default assignment operator that uses a const fromObj.
 */
   return SOM_ResolveD(this,USBDeviceCollection,SOMObject,somDefaultConstAssign)
	(this,ctrl,fromObj);
}


/* method: somDefaultVAssign */
USBDeviceCollection*  somDefaultVAssign(som3AssignCtrl* ctrl, 
		SOMObject* fromObj)
{
/*
 *  A default assignment operator that uses a volatile fromObj.
 */
   return SOM_ResolveD(this,USBDeviceCollection,SOMObject,somDefaultVAssign)
	(this,ctrl,fromObj);
}


/* method: somDefaultConstVAssign */
USBDeviceCollection*  somDefaultConstVAssign(som3AssignCtrl* ctrl, 
		SOMObject* fromObj)
{
/*
 *  A default assignment operator that uses a const volatile fromObj.
 */
   return SOM_ResolveD(this,USBDeviceCollection,SOMObject,somDefaultConstVAssign)
	(this,ctrl,fromObj);
}


/* method: somFree */
void   somFree()
{
/*
 *  Use as directed by framework implementations.
 */
   SOM_ResolveD(this,USBDeviceCollection,SOMObject,somFree)
	(this);
}


/* method: somGetClass */
SOMClass*   somGetClass()
{
/*
 *  Return the receiver's class.
 */
   return SOM_ResolveD(this,USBDeviceCollection,SOMObject,somGetClass)
	(this);
}


/* method: somGetClassName */
string   somGetClassName()
{
/*
 *  Return the name of the receiver's class.
 */
   return SOM_ResolveD(this,USBDeviceCollection,SOMObject,somGetClassName)
	(this);
}


/* method: somGetSize */
long   somGetSize()
{
/*
 *  Return the size of the receiver.
 */
   return SOM_ResolveD(this,USBDeviceCollection,SOMObject,somGetSize)
	(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_ResolveD(this,USBDeviceCollection,SOMObject,somIsA)
	(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_ResolveD(this,USBDeviceCollection,SOMObject,somIsInstanceOf)
	(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_ResolveD(this,USBDeviceCollection,SOMObject,somRespondsTo)
	(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.
 */
/* the va_list invocation form */
boolean   USBDeviceCollection_somDispatch(somToken* retValue, 
		somId methodId, 
		va_list ap)
{return SOM_ResolveD(this,USBDeviceCollection,SOMObject,somDispatch)
	(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.
 */
   va_list ap;
   va_start(ap, methodId);
   boolean __somResult = 
      SOM_ResolveD(this,USBDeviceCollection,SOMObject,somDispatch)
	(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   USBDeviceCollection_somClassDispatch(SOMClass* clsObj, 
		somToken* retValue, 
		somId methodId, 
		va_list ap)
{return SOM_ResolveD(this,USBDeviceCollection,SOMObject,somClassDispatch)
	(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_ResolveD(this,USBDeviceCollection,SOMObject,somClassDispatch)
	(this,clsObj,retValue,methodId,ap);
   va_end(ap);
   return __somResult;
}


/* method: somCastObj */
boolean   somCastObj(SOMClass* cls)
{
/*
 *  cast the receiving object to cls (which must be an ancestor of the
 *  objects true class. Returns true on success.
 */
   return SOM_ResolveD(this,USBDeviceCollection,SOMObject,somCastObj)
	(this,cls);
}


/* method: somResetObj */
boolean   somResetObj()
{
/*
 *  reset an object to its true class. Returns true always.
 */
   return SOM_ResolveD(this,USBDeviceCollection,SOMObject,somResetObj)
	(this);
}


/* va_list method: somDispatchV */

/*
 *  Obsolete. Use somDispatch instead.
 */
/* the va_list invocation form */
void   USBDeviceCollection_somDispatchV(somId methodId, 
		somId descriptor, 
		va_list ap)
{   SOM_ResolveD(this,USBDeviceCollection,SOMObject,somDispatchV)
	(this,methodId,descriptor,ap);
}

/* the varargs invocation form */
void   somDispatchV(somId methodId, 
		somId descriptor, 
		...)
{
/*
 *  Obsolete. Use somDispatch instead.
 */
   va_list ap;
   va_start(ap, descriptor);
   SOM_ResolveD(this,USBDeviceCollection,SOMObject,somDispatchV)
	(this,methodId,descriptor,ap);
   va_end(ap);
}


/* va_list method: somDispatchL */

/*
 *  Obsolete. Use somDispatch instead.
 */
/* the va_list invocation form */
long   USBDeviceCollection_somDispatchL(somId methodId, 
		somId descriptor, 
		va_list ap)
{return SOM_ResolveD(this,USBDeviceCollection,SOMObject,somDispatchL)
	(this,methodId,descriptor,ap);
}

/* the varargs invocation form */
long   somDispatchL(somId methodId, 
		somId descriptor, 
		...)
{
/*
 *  Obsolete. Use somDispatch instead.
 */
   va_list ap;
   va_start(ap, descriptor);
   long __somResult = 
      SOM_ResolveD(this,USBDeviceCollection,SOMObject,somDispatchL)
	(this,methodId,descriptor,ap);
   va_end(ap);
   return __somResult;
}


/* va_list method: somDispatchA */

/*
 *  Obsolete. Use somDispatch instead.
 */
/* the va_list invocation form */
void*   USBDeviceCollection_somDispatchA(somId methodId, 
		somId descriptor, 
		va_list ap)
{return SOM_ResolveD(this,USBDeviceCollection,SOMObject,somDispatchA)
	(this,methodId,descriptor,ap);
}

/* the varargs invocation form */
void*   somDispatchA(somId methodId, 
		somId descriptor, 
		...)
{
/*
 *  Obsolete. Use somDispatch instead.
 */
   va_list ap;
   va_start(ap, descriptor);
   void* __somResult = 
      SOM_ResolveD(this,USBDeviceCollection,SOMObject,somDispatchA)
	(this,methodId,descriptor,ap);
   va_end(ap);
   return __somResult;
}


/* va_list method: somDispatchD */

/*
 *  Obsolete. Use somDispatch instead.
 */
/* the va_list invocation form */
double   USBDeviceCollection_somDispatchD(somId methodId, 
		somId descriptor, 
		va_list ap)
{return SOM_ResolveD(this,USBDeviceCollection,SOMObject,somDispatchD)
	(this,methodId,descriptor,ap);
}

/* the varargs invocation form */
double   somDispatchD(somId methodId, 
		somId descriptor, 
		...)
{
/*
 *  Obsolete. Use somDispatch instead.
 */
   va_list ap;
   va_start(ap, descriptor);
   double __somResult = 
      SOM_ResolveD(this,USBDeviceCollection,SOMObject,somDispatchD)
	(this,methodId,descriptor,ap);
   va_end(ap);
   return __somResult;
}


/* method: somPrintSelf */
SOMObject*   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_ResolveD(this,USBDeviceCollection,SOMObject,somPrintSelf)
	(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_ResolveD(this,USBDeviceCollection,SOMObject,somDumpSelf)
	(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_ResolveD(this,USBDeviceCollection,SOMObject,somDumpSelfInt)
	(this,level);
}



};   /* USBDeviceCollection */



#endif       /* SOM_USBDeviceCollection_xh */

#ifndef SOM_RMDeviceObject_xh
#define SOM_RMDeviceObject_xh

class RMDeviceObject;

#define RMDeviceObject_MajorVersion 2
#define RMDeviceObject_MinorVersion 1

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

/* C++ parent defs */
#ifndef SOM_somf_MCollectible_xh
#include <mcollect.xh>
#endif

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

/*
 * Start of bindings for IDL types
 */


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

/* A procedure to create the RMDeviceObject Class */
SOMEXTERN SOMClass * SOMLINK RMDeviceObjectNewClass(
		integer4 majorVersion,
		integer4 minorVersion);

/* The API to the RMDeviceObject class object, and the methods it introduces. */
SOMEXTERN struct RMDeviceObjectClassDataStructure {
	SOMClass *classObject;
	somMToken _get_idVendor;
	somMToken _set_idVendor;
	somMToken _get_idProduct;
	somMToken _set_idProduct;
} SOMDLINK RMDeviceObjectClassData;
#define _RMDeviceObject RMDeviceObjectClassData.classObject

/* The API to parentMtabs for RMDeviceObject, and the instance data it introduces. */
SOMEXTERN struct RMDeviceObjectCClassDataStructure {
	somMethodTabs parentMtab;
	somDToken              instanceDataToken;
} SOMDLINK RMDeviceObjectCClassData;

/*
 * -- Typedefs for RMDeviceObject Method Procedures
 */
SOMEXTERN {
typedef long   SOMLINK somTP_RMDeviceObject__get_idVendor(RMDeviceObject *somSelf, Environment *ev);
typedef somTP_RMDeviceObject__get_idVendor *somTD_RMDeviceObject__get_idVendor;
typedef void   SOMLINK somTP_RMDeviceObject__set_idVendor(RMDeviceObject *somSelf, Environment *ev, 
		long idVendor);
typedef somTP_RMDeviceObject__set_idVendor *somTD_RMDeviceObject__set_idVendor;
typedef long   SOMLINK somTP_RMDeviceObject__get_idProduct(RMDeviceObject *somSelf, Environment *ev);
typedef somTP_RMDeviceObject__get_idProduct *somTD_RMDeviceObject__get_idProduct;
typedef void   SOMLINK somTP_RMDeviceObject__set_idProduct(RMDeviceObject *somSelf, Environment *ev, 
		long idProduct);
typedef somTP_RMDeviceObject__set_idProduct *somTD_RMDeviceObject__set_idProduct;

/*
 * -- Typedefs for Reintroduced Wrapper Methods
 */
typedef somf_MCollectible*   SOMLINK somTP_RMDeviceObject_somfClone(RMDeviceObject *somSelf, Environment *ev);
typedef somTP_RMDeviceObject_somfClone *somTD_RMDeviceObject_somfClone;
typedef somf_MCollectible*   SOMLINK somTP_RMDeviceObject_somfClonePointer(RMDeviceObject *somSelf, Environment *ev, 
		somf_MCollectible* clonee);
typedef somTP_RMDeviceObject_somfClonePointer *somTD_RMDeviceObject_somfClonePointer;
typedef long   SOMLINK somTP_RMDeviceObject_somfHash(RMDeviceObject *somSelf, Environment *ev);
typedef somTP_RMDeviceObject_somfHash *somTD_RMDeviceObject_somfHash;
typedef boolean   SOMLINK somTP_RMDeviceObject_somfIsEqual(RMDeviceObject *somSelf, Environment *ev, 
		somf_MCollectible* obj);
typedef somTP_RMDeviceObject_somfIsEqual *somTD_RMDeviceObject_somfIsEqual;
typedef boolean   SOMLINK somTP_RMDeviceObject_somfIsSame(RMDeviceObject *somSelf, Environment *ev, 
		somf_MCollectible* obj);
typedef somTP_RMDeviceObject_somfIsSame *somTD_RMDeviceObject_somfIsSame;
typedef boolean   SOMLINK somTP_RMDeviceObject_somfIsNotEqual(RMDeviceObject *somSelf, Environment *ev, 
		somf_MCollectible* obj);
typedef somTP_RMDeviceObject_somfIsNotEqual *somTD_RMDeviceObject_somfIsNotEqual;
typedef void   SOMLINK somTP_RMDeviceObject_somDefaultInit(RMDeviceObject *somSelf, 
		som3InitCtrl* ctrl);
typedef somTP_RMDeviceObject_somDefaultInit *somTD_RMDeviceObject_somDefaultInit;
typedef void   SOMLINK somTP_RMDeviceObject_somDestruct(RMDeviceObject *somSelf, 
		octet doFree, 
		som3DestructCtrl* ctrl);
typedef somTP_RMDeviceObject_somDestruct *somTD_RMDeviceObject_somDestruct;
typedef void   SOMLINK somTP_RMDeviceObject_somDefaultCopyInit(RMDeviceObject *somSelf, 
		som3InitCtrl* ctrl, 
		SOMObject* fromObj);
typedef somTP_RMDeviceObject_somDefaultCopyInit *somTD_RMDeviceObject_somDefaultCopyInit;
typedef RMDeviceObject*   SOMLINK somTP_RMDeviceObject_somDefaultAssign(RMDeviceObject *somSelf, 
		som3AssignCtrl* ctrl, 
		SOMObject* fromObj);
typedef somTP_RMDeviceObject_somDefaultAssign *somTD_RMDeviceObject_somDefaultAssign;
typedef void   SOMLINK somTP_RMDeviceObject_somDefaultConstCopyInit(RMDeviceObject *somSelf, 
		som3InitCtrl* ctrl, 
		SOMObject* fromObj);
typedef somTP_RMDeviceObject_somDefaultConstCopyInit *somTD_RMDeviceObject_somDefaultConstCopyInit;
typedef void   SOMLINK somTP_RMDeviceObject_somDefaultVCopyInit(RMDeviceObject *somSelf, 
		som3InitCtrl* ctrl, 
		SOMObject* fromObj);
typedef somTP_RMDeviceObject_somDefaultVCopyInit *somTD_RMDeviceObject_somDefaultVCopyInit;
typedef void   SOMLINK somTP_RMDeviceObject_somDefaultConstVCopyInit(RMDeviceObject *somSelf, 
		som3InitCtrl* ctrl, 
		SOMObject* fromObj);
typedef somTP_RMDeviceObject_somDefaultConstVCopyInit *somTD_RMDeviceObject_somDefaultConstVCopyInit;
typedef RMDeviceObject*   SOMLINK somTP_RMDeviceObject_somDefaultConstAssign(RMDeviceObject *somSelf, 
		som3AssignCtrl* ctrl, 
		SOMObject* fromObj);
typedef somTP_RMDeviceObject_somDefaultConstAssign *somTD_RMDeviceObject_somDefaultConstAssign;
typedef RMDeviceObject*   SOMLINK somTP_RMDeviceObject_somDefaultVAssign(RMDeviceObject *somSelf, 
		som3AssignCtrl* ctrl, 
		SOMObject* fromObj);
typedef somTP_RMDeviceObject_somDefaultVAssign *somTD_RMDeviceObject_somDefaultVAssign;
typedef RMDeviceObject*   SOMLINK somTP_RMDeviceObject_somDefaultConstVAssign(RMDeviceObject *somSelf, 
		som3AssignCtrl* ctrl, 
		SOMObject* fromObj);
typedef somTP_RMDeviceObject_somDefaultConstVAssign *somTD_RMDeviceObject_somDefaultConstVAssign;
typedef void   SOMLINK somTP_RMDeviceObject_somInit(RMDeviceObject *somSelf);
typedef somTP_RMDeviceObject_somInit *somTD_RMDeviceObject_somInit;
typedef void   SOMLINK somTP_RMDeviceObject_somFree(RMDeviceObject *somSelf);
typedef somTP_RMDeviceObject_somFree *somTD_RMDeviceObject_somFree;
typedef void   SOMLINK somTP_RMDeviceObject_somUninit(RMDeviceObject *somSelf);
typedef somTP_RMDeviceObject_somUninit *somTD_RMDeviceObject_somUninit;
typedef SOMClass*   SOMLINK somTP_RMDeviceObject_somGetClass(RMDeviceObject *somSelf);
typedef somTP_RMDeviceObject_somGetClass *somTD_RMDeviceObject_somGetClass;
typedef string   SOMLINK somTP_RMDeviceObject_somGetClassName(RMDeviceObject *somSelf);
typedef somTP_RMDeviceObject_somGetClassName *somTD_RMDeviceObject_somGetClassName;
typedef long   SOMLINK somTP_RMDeviceObject_somGetSize(RMDeviceObject *somSelf);
typedef somTP_RMDeviceObject_somGetSize *somTD_RMDeviceObject_somGetSize;
typedef boolean   SOMLINK somTP_RMDeviceObject_somIsA(RMDeviceObject *somSelf, 
		SOMClass* aClassObj);
typedef somTP_RMDeviceObject_somIsA *somTD_RMDeviceObject_somIsA;
typedef boolean   SOMLINK somTP_RMDeviceObject_somIsInstanceOf(RMDeviceObject *somSelf, 
		SOMClass* aClassObj);
typedef somTP_RMDeviceObject_somIsInstanceOf *somTD_RMDeviceObject_somIsInstanceOf;
typedef boolean   SOMLINK somTP_RMDeviceObject_somRespondsTo(RMDeviceObject *somSelf, 
		somId mId);
typedef somTP_RMDeviceObject_somRespondsTo *somTD_RMDeviceObject_somRespondsTo;
typedef boolean   SOMLINK somTP_RMDeviceObject_somDispatch(RMDeviceObject *somSelf, 
		somToken* retValue, 
		somId methodId, 
		va_list ap);
typedef somTP_RMDeviceObject_somDispatch *somTD_RMDeviceObject_somDispatch;
typedef boolean   SOMLINK somTP_RMDeviceObject_somClassDispatch(RMDeviceObject *somSelf, 
		SOMClass* clsObj, 
		somToken* retValue, 
		somId methodId, 
		va_list ap);
typedef somTP_RMDeviceObject_somClassDispatch *somTD_RMDeviceObject_somClassDispatch;
typedef boolean   SOMLINK somTP_RMDeviceObject_somCastObj(RMDeviceObject *somSelf, 
		SOMClass* cls);
typedef somTP_RMDeviceObject_somCastObj *somTD_RMDeviceObject_somCastObj;
typedef boolean   SOMLINK somTP_RMDeviceObject_somResetObj(RMDeviceObject *somSelf);
typedef somTP_RMDeviceObject_somResetObj *somTD_RMDeviceObject_somResetObj;
typedef void   SOMLINK somTP_RMDeviceObject_somDispatchV(RMDeviceObject *somSelf, 
		somId methodId, 
		somId descriptor, 
		va_list ap);
typedef somTP_RMDeviceObject_somDispatchV *somTD_RMDeviceObject_somDispatchV;
typedef long   SOMLINK somTP_RMDeviceObject_somDispatchL(RMDeviceObject *somSelf, 
		somId methodId, 
		somId descriptor, 
		va_list ap);
typedef somTP_RMDeviceObject_somDispatchL *somTD_RMDeviceObject_somDispatchL;
typedef void*   SOMLINK somTP_RMDeviceObject_somDispatchA(RMDeviceObject *somSelf, 
		somId methodId, 
		somId descriptor, 
		va_list ap);
typedef somTP_RMDeviceObject_somDispatchA *somTD_RMDeviceObject_somDispatchA;
typedef double   SOMLINK somTP_RMDeviceObject_somDispatchD(RMDeviceObject *somSelf, 
		somId methodId, 
		somId descriptor, 
		va_list ap);
typedef somTP_RMDeviceObject_somDispatchD *somTD_RMDeviceObject_somDispatchD;
typedef SOMObject*   SOMLINK somTP_RMDeviceObject_somPrintSelf(RMDeviceObject *somSelf);
typedef somTP_RMDeviceObject_somPrintSelf *somTD_RMDeviceObject_somPrintSelf;
typedef void   SOMLINK somTP_RMDeviceObject_somDumpSelf(RMDeviceObject *somSelf, 
		long level);
typedef somTP_RMDeviceObject_somDumpSelf *somTD_RMDeviceObject_somDumpSelf;
typedef void   SOMLINK somTP_RMDeviceObject_somDumpSelfInt(RMDeviceObject *somSelf, 
		long level);
typedef somTP_RMDeviceObject_somDumpSelfInt *somTD_RMDeviceObject_somDumpSelfInt;
}

#endif /* RMDeviceObject_API */


/*
 * -- This emitter treats Method Tokens as Thunks by default.
 * -- Use the sc modifier "nothunks" to change this default
 */
#undef somresolve_
#define somresolve_(obj,mToken) ((somMethodProc*)((void)obj, mToken))

/*
 * -- The C++ Wrapper Class for RMDeviceObject
 */
class RMDeviceObject : public somf_MCollectible
{
public:

// RMDeviceObject::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 (!_RMDeviceObject) RMDeviceObjectNewClass(RMDeviceObject_MajorVersion,RMDeviceObject_MinorVersion);
   return (void*)
      SOM_Resolve(_RMDeviceObject,SOMClass,somNewNoInit)
         ((SOMClass *)((void*)_RMDeviceObject));
}

// RMDeviceObject::delete uses somDestruct.
void operator delete(void * obj)
{
   if (obj && *(void**)obj) {
      SOM_Resolve(obj,SOMObject,somFree)
         ((SOMObject*)obj);
   }
}

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

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

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

#ifdef __IBMCPP__
#pragma info(nocnv,nopar)
#endif
RMDeviceObject(const RMDeviceObject* fromObj)
{
   if (*(void**)this != 
       ((somParentMtabStructPtr)
        (RMDeviceObjectCClassData.parentMtab))->mtab)
      return;
   ((SOMObject*)((void*)this))->somDefaultConstCopyInit(0,((SOMObject*)((void*)fromObj)));
}
#ifdef __IBMCPP__
#pragma info(restore)
#endif


/* method: _get_idVendor */
long   _get_idVendor(Environment *ev)
{
/*
 * Method from the IDL attribute statement:
 * "attribute long idVendor"
 */
   return SOM_ResolveD(this,RMDeviceObject,RMDeviceObject,_get_idVendor)
	(this, ev);
}


/* method: _set_idVendor */
void   _set_idVendor(Environment *ev, 
		long idVendor)
{
/*
 * Method from the IDL attribute statement:
 * "attribute long idVendor"
 */
   SOM_ResolveD(this,RMDeviceObject,RMDeviceObject,_set_idVendor)
	(this, ev,idVendor);
}


/* method: _get_idProduct */
long   _get_idProduct(Environment *ev)
{
/*
 * Method from the IDL attribute statement:
 * "attribute long idProduct"
 */
   return SOM_ResolveD(this,RMDeviceObject,RMDeviceObject,_get_idProduct)
	(this, ev);
}


/* method: _set_idProduct */
void   _set_idProduct(Environment *ev, 
		long idProduct)
{
/*
 * Method from the IDL attribute statement:
 * "attribute long idProduct"
 */
   SOM_ResolveD(this,RMDeviceObject,RMDeviceObject,_set_idProduct)
	(this, ev,idProduct);
}


/*
 * Reintroduce inherited methods
 */

/* method: somfClone */
somf_MCollectible*   somfClone(Environment *ev)
{
/*
 *  somfClone provides a general function for creating a new instance of this.
 */
   return SOM_ResolveD(this,RMDeviceObject,somf_MCollectible,somfClone)
	(this, ev);
}


/* method: somfClonePointer */
somf_MCollectible*   somfClonePointer(Environment *ev, 
		somf_MCollectible* clonee)
{
/*
 *  somfClonePointer returns a pointer to a Clone
 */
   return SOM_ResolveD(this,RMDeviceObject,somf_MCollectible,somfClonePointer)
	(this, ev,clonee);
}


/* method: somfHash */
long   somfHash(Environment *ev)
{
/*
 *  somfHash returns a value suitable for use as a hashing probe for this.
 *  The default function will simply return the address of the object.
 *  The default function is almost certainly not adequate if you are overriding
 *  somfIsEqual because you need to make sure that all objects that "are equal"
 *  to each other return the same hash value.  For example, a TText object would
 *  return a hash value computed using the characters in the string instead of
 *  the address of the string.
 */
   return SOM_ResolveD(this,RMDeviceObject,somf_MCollectible,somfHash)
	(this, ev);
}


/* method: somfIsEqual */
boolean   somfIsEqual(Environment *ev, 
		somf_MCollectible* obj)
{
/*
 *  somfIsEqual returns TRUE if obj is isomorphic to this.  The default function
 *  will give you a nasty message.  For example, the somfIsEqual method
 *  for TText objects will do a string comparison.  All of the utility classes
 *  allow you to specify what methods to use when comparing objects for
 *  insertion, deletion, etc.
 */
   return SOM_ResolveD(this,RMDeviceObject,somf_MCollectible,somfIsEqual)
	(this, ev,obj);
}


/* method: somfIsSame */
boolean   somfIsSame(Environment *ev, 
		somf_MCollectible* obj)
{
/*
 *  The default function for somfIsSame is a pointer comparison
 */
   return SOM_ResolveD(this,RMDeviceObject,somf_MCollectible,somfIsSame)
	(this, ev,obj);
}


/* method: somfIsNotEqual */
boolean   somfIsNotEqual(Environment *ev, 
		somf_MCollectible* obj)
{
/*
 *  somfIsNotEqual returns TRUE if obj is NOT isomorphic to this.  It uses
 *  somfIsEqual, so overriding somfIsEqual will handle the logic of somfIsNotEqual too.
 */
   return SOM_ResolveD(this,RMDeviceObject,somf_MCollectible,somfIsNotEqual)
	(this, ev,obj);
}


/* 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_ResolveD(this,RMDeviceObject,SOMObject,somDefaultInit)
	(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_ResolveD(this,RMDeviceObject,SOMObject,somDestruct)
	(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_ResolveD(this,RMDeviceObject,SOMObject,somDefaultCopyInit)
	(this,ctrl,fromObj);
}


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


/* initializer method: somDefaultConstCopyInit */
void   somDefaultConstCopyInit(som3InitCtrl* ctrl, 
		SOMObject* fromObj)
{
/*
 *  A default copy constructor that uses a const fromObj.
 */
   SOM_ResolveD(this,RMDeviceObject,SOMObject,somDefaultConstCopyInit)
	(this,ctrl,fromObj);
}


/* initializer method: somDefaultVCopyInit */
void   somDefaultVCopyInit(som3InitCtrl* ctrl, 
		SOMObject* fromObj)
{
/*
 *  A default copy constructor that uses a volatile fromObj.
 */
   SOM_ResolveD(this,RMDeviceObject,SOMObject,somDefaultVCopyInit)
	(this,ctrl,fromObj);
}


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


/* method: somDefaultConstAssign */
RMDeviceObject*  somDefaultConstAssign(som3AssignCtrl* ctrl, 
		SOMObject* fromObj)
{
/*
 *  A default assignment operator that uses a const fromObj.
 */
   return SOM_ResolveD(this,RMDeviceObject,SOMObject,somDefaultConstAssign)
	(this,ctrl,fromObj);
}


/* method: somDefaultVAssign */
RMDeviceObject*  somDefaultVAssign(som3AssignCtrl* ctrl, 
		SOMObject* fromObj)
{
/*
 *  A default assignment operator that uses a volatile fromObj.
 */
   return SOM_ResolveD(this,RMDeviceObject,SOMObject,somDefaultVAssign)
	(this,ctrl,fromObj);
}


/* method: somDefaultConstVAssign */
RMDeviceObject*  somDefaultConstVAssign(som3AssignCtrl* ctrl, 
		SOMObject* fromObj)
{
/*
 *  A default assignment operator that uses a const volatile fromObj.
 */
   return SOM_ResolveD(this,RMDeviceObject,SOMObject,somDefaultConstVAssign)
	(this,ctrl,fromObj);
}


/* method: somInit */
void   somInit()
{
/*
 *  Obsolete but still supported. Override somDefaultInit instead of somInit.
 */
   SOM_ResolveD(this,RMDeviceObject,SOMObject,somInit)
	(this);
}


/* method: somFree */
void   somFree()
{
/*
 *  Use as directed by framework implementations.
 */
   SOM_ResolveD(this,RMDeviceObject,SOMObject,somFree)
	(this);
}


/* method: somUninit */
void   somUninit()
{
/*
 *  Obsolete but still supported. Override somDestruct instead of somUninit.
 */
   SOM_ResolveD(this,RMDeviceObject,SOMObject,somUninit)
	(this);
}


/* method: somGetClass */
SOMClass*   somGetClass()
{
/*
 *  Return the receiver's class.
 */
   return SOM_ResolveD(this,RMDeviceObject,SOMObject,somGetClass)
	(this);
}


/* method: somGetClassName */
string   somGetClassName()
{
/*
 *  Return the name of the receiver's class.
 */
   return SOM_ResolveD(this,RMDeviceObject,SOMObject,somGetClassName)
	(this);
}


/* method: somGetSize */
long   somGetSize()
{
/*
 *  Return the size of the receiver.
 */
   return SOM_ResolveD(this,RMDeviceObject,SOMObject,somGetSize)
	(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_ResolveD(this,RMDeviceObject,SOMObject,somIsA)
	(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_ResolveD(this,RMDeviceObject,SOMObject,somIsInstanceOf)
	(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_ResolveD(this,RMDeviceObject,SOMObject,somRespondsTo)
	(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.
 */
/* the va_list invocation form */
boolean   RMDeviceObject_somDispatch(somToken* retValue, 
		somId methodId, 
		va_list ap)
{return SOM_ResolveD(this,RMDeviceObject,SOMObject,somDispatch)
	(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.
 */
   va_list ap;
   va_start(ap, methodId);
   boolean __somResult = 
      SOM_ResolveD(this,RMDeviceObject,SOMObject,somDispatch)
	(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   RMDeviceObject_somClassDispatch(SOMClass* clsObj, 
		somToken* retValue, 
		somId methodId, 
		va_list ap)
{return SOM_ResolveD(this,RMDeviceObject,SOMObject,somClassDispatch)
	(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_ResolveD(this,RMDeviceObject,SOMObject,somClassDispatch)
	(this,clsObj,retValue,methodId,ap);
   va_end(ap);
   return __somResult;
}


/* method: somCastObj */
boolean   somCastObj(SOMClass* cls)
{
/*
 *  cast the receiving object to cls (which must be an ancestor of the
 *  objects true class. Returns true on success.
 */
   return SOM_ResolveD(this,RMDeviceObject,SOMObject,somCastObj)
	(this,cls);
}


/* method: somResetObj */
boolean   somResetObj()
{
/*
 *  reset an object to its true class. Returns true always.
 */
   return SOM_ResolveD(this,RMDeviceObject,SOMObject,somResetObj)
	(this);
}


/* va_list method: somDispatchV */

/*
 *  Obsolete. Use somDispatch instead.
 */
/* the va_list invocation form */
void   RMDeviceObject_somDispatchV(somId methodId, 
		somId descriptor, 
		va_list ap)
{   SOM_ResolveD(this,RMDeviceObject,SOMObject,somDispatchV)
	(this,methodId,descriptor,ap);
}

/* the varargs invocation form */
void   somDispatchV(somId methodId, 
		somId descriptor, 
		...)
{
/*
 *  Obsolete. Use somDispatch instead.
 */
   va_list ap;
   va_start(ap, descriptor);
   SOM_ResolveD(this,RMDeviceObject,SOMObject,somDispatchV)
	(this,methodId,descriptor,ap);
   va_end(ap);
}


/* va_list method: somDispatchL */

/*
 *  Obsolete. Use somDispatch instead.
 */
/* the va_list invocation form */
long   RMDeviceObject_somDispatchL(somId methodId, 
		somId descriptor, 
		va_list ap)
{return SOM_ResolveD(this,RMDeviceObject,SOMObject,somDispatchL)
	(this,methodId,descriptor,ap);
}

/* the varargs invocation form */
long   somDispatchL(somId methodId, 
		somId descriptor, 
		...)
{
/*
 *  Obsolete. Use somDispatch instead.
 */
   va_list ap;
   va_start(ap, descriptor);
   long __somResult = 
      SOM_ResolveD(this,RMDeviceObject,SOMObject,somDispatchL)
	(this,methodId,descriptor,ap);
   va_end(ap);
   return __somResult;
}


/* va_list method: somDispatchA */

/*
 *  Obsolete. Use somDispatch instead.
 */
/* the va_list invocation form */
void*   RMDeviceObject_somDispatchA(somId methodId, 
		somId descriptor, 
		va_list ap)
{return SOM_ResolveD(this,RMDeviceObject,SOMObject,somDispatchA)
	(this,methodId,descriptor,ap);
}

/* the varargs invocation form */
void*   somDispatchA(somId methodId, 
		somId descriptor, 
		...)
{
/*
 *  Obsolete. Use somDispatch instead.
 */
   va_list ap;
   va_start(ap, descriptor);
   void* __somResult = 
      SOM_ResolveD(this,RMDeviceObject,SOMObject,somDispatchA)
	(this,methodId,descriptor,ap);
   va_end(ap);
   return __somResult;
}


/* va_list method: somDispatchD */

/*
 *  Obsolete. Use somDispatch instead.
 */
/* the va_list invocation form */
double   RMDeviceObject_somDispatchD(somId methodId, 
		somId descriptor, 
		va_list ap)
{return SOM_ResolveD(this,RMDeviceObject,SOMObject,somDispatchD)
	(this,methodId,descriptor,ap);
}

/* the varargs invocation form */
double   somDispatchD(somId methodId, 
		somId descriptor, 
		...)
{
/*
 *  Obsolete. Use somDispatch instead.
 */
   va_list ap;
   va_start(ap, descriptor);
   double __somResult = 
      SOM_ResolveD(this,RMDeviceObject,SOMObject,somDispatchD)
	(this,methodId,descriptor,ap);
   va_end(ap);
   return __somResult;
}


/* method: somPrintSelf */
SOMObject*   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_ResolveD(this,RMDeviceObject,SOMObject,somPrintSelf)
	(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_ResolveD(this,RMDeviceObject,SOMObject,somDumpSelf)
	(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_ResolveD(this,RMDeviceObject,SOMObject,somDumpSelfInt)
	(this,level);
}



};   /* RMDeviceObject */



#endif       /* SOM_RMDeviceObject_xh */

#ifndef SOM_RMDeviceCollection_xh
#define SOM_RMDeviceCollection_xh

class RMDeviceCollection;

#define RMDeviceCollection_MajorVersion 2
#define RMDeviceCollection_MinorVersion 1

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

/* C++ parent defs */
#ifndef SOM_somf_THashTable_xh
#include <thash.xh>
#endif

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

/*
 * Start of bindings for IDL types
 */


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

/* A procedure to create the RMDeviceCollection Class */
class M_RMDeviceCollection;
SOMEXTERN M_RMDeviceCollection * SOMLINK RMDeviceCollectionNewClass(
		integer4 majorVersion,
		integer4 minorVersion);

/* The API to the RMDeviceCollection class object, and the methods it introduces. */
SOMEXTERN struct RMDeviceCollectionClassDataStructure {
	M_RMDeviceCollection *classObject;
	somMToken addRMDevice;
	somMToken findRMDevice;
	somMToken deleteRMDevice;
} SOMDLINK RMDeviceCollectionClassData;
#define _RMDeviceCollection RMDeviceCollectionClassData.classObject

/* The API to parentMtabs for RMDeviceCollection, and the instance data it introduces. */
SOMEXTERN struct RMDeviceCollectionCClassDataStructure {
	somMethodTabs parentMtab;
	somDToken              instanceDataToken;
} SOMDLINK RMDeviceCollectionCClassData;

/*
 * -- Typedefs for RMDeviceCollection Method Procedures
 */
SOMEXTERN {
typedef RMDeviceObject*   SOMLINK somTP_RMDeviceCollection_addRMDevice(RMDeviceCollection *somSelf, Environment *ev, 
		long key, 
		long idVendor, 
		long idProduct);
typedef somTP_RMDeviceCollection_addRMDevice *somTD_RMDeviceCollection_addRMDevice;
typedef RMDeviceObject*   SOMLINK somTP_RMDeviceCollection_findRMDevice(RMDeviceCollection *somSelf, Environment *ev, 
		long key);
typedef somTP_RMDeviceCollection_findRMDevice *somTD_RMDeviceCollection_findRMDevice;
typedef void   SOMLINK somTP_RMDeviceCollection_deleteRMDevice(RMDeviceCollection *somSelf, Environment *ev, 
		long key);
typedef somTP_RMDeviceCollection_deleteRMDevice *somTD_RMDeviceCollection_deleteRMDevice;

/*
 * -- Typedefs for Reintroduced Wrapper Methods
 */
typedef somf_THashTable*   SOMLINK somTP_RMDeviceCollection_somfTHashTableInitFLLL(RMDeviceCollection *somSelf, Environment *ev, 
		somf_MCollectible_somf_MCollectibleCompareFn testfn, 
		long tablesize, 
		long rate, 
		long threshold);
typedef somTP_RMDeviceCollection_somfTHashTableInitFLLL *somTD_RMDeviceCollection_somfTHashTableInitFLLL;
typedef somf_THashTable*   SOMLINK somTP_RMDeviceCollection_somfTHashTableInitFLL(RMDeviceCollection *somSelf, Environment *ev, 
		somf_MCollectible_somf_MCollectibleCompareFn testfn, 
		long tablesize, 
		long rate);
typedef somTP_RMDeviceCollection_somfTHashTableInitFLL *somTD_RMDeviceCollection_somfTHashTableInitFLL;
typedef somf_THashTable*   SOMLINK somTP_RMDeviceCollection_somfTHashTableInitFL(RMDeviceCollection *somSelf, Environment *ev, 
		somf_MCollectible_somf_MCollectibleCompareFn testfn, 
		long tablesize);
typedef somTP_RMDeviceCollection_somfTHashTableInitFL *somTD_RMDeviceCollection_somfTHashTableInitFL;
typedef somf_THashTable*   SOMLINK somTP_RMDeviceCollection_somfTHashTableInitH(RMDeviceCollection *somSelf, Environment *ev, 
		somf_THashTable* h);
typedef somTP_RMDeviceCollection_somfTHashTableInitH *somTD_RMDeviceCollection_somfTHashTableInitH;
typedef void   SOMLINK somTP_RMDeviceCollection_somfAssign(RMDeviceCollection *somSelf, Environment *ev, 
		somf_THashTable* source);
typedef somTP_RMDeviceCollection_somfAssign *somTD_RMDeviceCollection_somfAssign;
typedef long   SOMLINK somTP_RMDeviceCollection_somfCount(RMDeviceCollection *somSelf, Environment *ev);
typedef somTP_RMDeviceCollection_somfCount *somTD_RMDeviceCollection_somfCount;
typedef somf_MCollectible*   SOMLINK somTP_RMDeviceCollection_somfRemove(RMDeviceCollection *somSelf, Environment *ev, 
		somf_MCollectible* key);
typedef somTP_RMDeviceCollection_somfRemove *somTD_RMDeviceCollection_somfRemove;
typedef somf_MCollectible*   SOMLINK somTP_RMDeviceCollection_somfDelete(RMDeviceCollection *somSelf, Environment *ev, 
		somf_MCollectible* key);
typedef somTP_RMDeviceCollection_somfDelete *somTD_RMDeviceCollection_somfDelete;
typedef somf_MCollectible*   SOMLINK somTP_RMDeviceCollection_somfMember(RMDeviceCollection *somSelf, Environment *ev, 
		somf_MCollectible* key);
typedef somTP_RMDeviceCollection_somfMember *somTD_RMDeviceCollection_somfMember;
typedef void   SOMLINK somTP_RMDeviceCollection_somfRemoveAll(RMDeviceCollection *somSelf, Environment *ev);
typedef somTP_RMDeviceCollection_somfRemoveAll *somTD_RMDeviceCollection_somfRemoveAll;
typedef void   SOMLINK somTP_RMDeviceCollection_somfDeleteAll(RMDeviceCollection *somSelf, Environment *ev);
typedef somTP_RMDeviceCollection_somfDeleteAll *somTD_RMDeviceCollection_somfDeleteAll;
typedef void   SOMLINK somTP_RMDeviceCollection_somfDeleteAllKeys(RMDeviceCollection *somSelf, Environment *ev);
typedef somTP_RMDeviceCollection_somfDeleteAllKeys *somTD_RMDeviceCollection_somfDeleteAllKeys;
typedef void   SOMLINK somTP_RMDeviceCollection_somfDeleteAllValues(RMDeviceCollection *somSelf, Environment *ev);
typedef somTP_RMDeviceCollection_somfDeleteAllValues *somTD_RMDeviceCollection_somfDeleteAllValues;
typedef somf_MCollectible*   SOMLINK somTP_RMDeviceCollection_somfAddMMB(RMDeviceCollection *somSelf, Environment *ev, 
		somf_MCollectible* key, 
		somf_MCollectible* value, 
		boolean replace);
typedef somTP_RMDeviceCollection_somfAddMMB *somTD_RMDeviceCollection_somfAddMMB;
typedef somf_MCollectible*   SOMLINK somTP_RMDeviceCollection_somfAddMM(RMDeviceCollection *somSelf, Environment *ev, 
		somf_MCollectible* key, 
		somf_MCollectible* value);
typedef somTP_RMDeviceCollection_somfAddMM *somTD_RMDeviceCollection_somfAddMM;
typedef void   SOMLINK somTP_RMDeviceCollection_somfGrow(RMDeviceCollection *somSelf, Environment *ev);
typedef somTP_RMDeviceCollection_somfGrow *somTD_RMDeviceCollection_somfGrow;
typedef somf_MCollectible*   SOMLINK somTP_RMDeviceCollection_somfRetrieve(RMDeviceCollection *somSelf, Environment *ev, 
		somf_MCollectible* key);
typedef somTP_RMDeviceCollection_somfRetrieve *somTD_RMDeviceCollection_somfRetrieve;
typedef void   SOMLINK somTP_RMDeviceCollection_somfSetGrowthRate(RMDeviceCollection *somSelf, Environment *ev, 
		long rate);
typedef somTP_RMDeviceCollection_somfSetGrowthRate *somTD_RMDeviceCollection_somfSetGrowthRate;
typedef void   SOMLINK somTP_RMDeviceCollection_somfSetRehashThreshold(RMDeviceCollection *somSelf, Environment *ev, 
		long threshold);
typedef somTP_RMDeviceCollection_somfSetRehashThreshold *somTD_RMDeviceCollection_somfSetRehashThreshold;
typedef long   SOMLINK somTP_RMDeviceCollection_somfGetGrowthRate(RMDeviceCollection *somSelf, Environment *ev);
typedef somTP_RMDeviceCollection_somfGetGrowthRate *somTD_RMDeviceCollection_somfGetGrowthRate;
typedef long   SOMLINK somTP_RMDeviceCollection_somfGetRehashThreshold(RMDeviceCollection *somSelf, Environment *ev);
typedef somTP_RMDeviceCollection_somfGetRehashThreshold *somTD_RMDeviceCollection_somfGetRehashThreshold;
typedef void   SOMLINK somTP_RMDeviceCollection_somfSetHashFunction(RMDeviceCollection *somSelf, Environment *ev, 
		somf_MCollectible_somf_MCollectibleHashFn fn);
typedef somTP_RMDeviceCollection_somfSetHashFunction *somTD_RMDeviceCollection_somfSetHashFunction;
typedef somf_MCollectible_somf_MCollectibleHashFn   SOMLINK somTP_RMDeviceCollection_somfGetHashFunction(RMDeviceCollection *somSelf, Environment *ev);
typedef somTP_RMDeviceCollection_somfGetHashFunction *somTD_RMDeviceCollection_somfGetHashFunction;
typedef void   SOMLINK somTP_RMDeviceCollection_somInit(RMDeviceCollection *somSelf);
typedef somTP_RMDeviceCollection_somInit *somTD_RMDeviceCollection_somInit;
typedef void   SOMLINK somTP_RMDeviceCollection_somUninit(RMDeviceCollection *somSelf);
typedef somTP_RMDeviceCollection_somUninit *somTD_RMDeviceCollection_somUninit;
typedef somf_MCollectible*   SOMLINK somTP_RMDeviceCollection_somfClone(RMDeviceCollection *somSelf, Environment *ev);
typedef somTP_RMDeviceCollection_somfClone *somTD_RMDeviceCollection_somfClone;
typedef somf_MCollectible*   SOMLINK somTP_RMDeviceCollection_somfClonePointer(RMDeviceCollection *somSelf, Environment *ev, 
		somf_MCollectible* clonee);
typedef somTP_RMDeviceCollection_somfClonePointer *somTD_RMDeviceCollection_somfClonePointer;
typedef long   SOMLINK somTP_RMDeviceCollection_somfHash(RMDeviceCollection *somSelf, Environment *ev);
typedef somTP_RMDeviceCollection_somfHash *somTD_RMDeviceCollection_somfHash;
typedef boolean   SOMLINK somTP_RMDeviceCollection_somfIsEqual(RMDeviceCollection *somSelf, Environment *ev, 
		somf_MCollectible* obj);
typedef somTP_RMDeviceCollection_somfIsEqual *somTD_RMDeviceCollection_somfIsEqual;
typedef boolean   SOMLINK somTP_RMDeviceCollection_somfIsSame(RMDeviceCollection *somSelf, Environment *ev, 
		somf_MCollectible* obj);
typedef somTP_RMDeviceCollection_somfIsSame *somTD_RMDeviceCollection_somfIsSame;
typedef boolean   SOMLINK somTP_RMDeviceCollection_somfIsNotEqual(RMDeviceCollection *somSelf, Environment *ev, 
		somf_MCollectible* obj);
typedef somTP_RMDeviceCollection_somfIsNotEqual *somTD_RMDeviceCollection_somfIsNotEqual;
typedef void   SOMLINK somTP_RMDeviceCollection_somDefaultInit(RMDeviceCollection *somSelf, 
		som3InitCtrl* ctrl);
typedef somTP_RMDeviceCollection_somDefaultInit *somTD_RMDeviceCollection_somDefaultInit;
typedef void   SOMLINK somTP_RMDeviceCollection_somDestruct(RMDeviceCollection *somSelf, 
		octet doFree, 
		som3DestructCtrl* ctrl);
typedef somTP_RMDeviceCollection_somDestruct *somTD_RMDeviceCollection_somDestruct;
typedef void   SOMLINK somTP_RMDeviceCollection_somDefaultCopyInit(RMDeviceCollection *somSelf, 
		som3InitCtrl* ctrl, 
		SOMObject* fromObj);
typedef somTP_RMDeviceCollection_somDefaultCopyInit *somTD_RMDeviceCollection_somDefaultCopyInit;
typedef RMDeviceCollection*   SOMLINK somTP_RMDeviceCollection_somDefaultAssign(RMDeviceCollection *somSelf, 
		som3AssignCtrl* ctrl, 
		SOMObject* fromObj);
typedef somTP_RMDeviceCollection_somDefaultAssign *somTD_RMDeviceCollection_somDefaultAssign;
typedef void   SOMLINK somTP_RMDeviceCollection_somDefaultConstCopyInit(RMDeviceCollection *somSelf, 
		som3InitCtrl* ctrl, 
		SOMObject* fromObj);
typedef somTP_RMDeviceCollection_somDefaultConstCopyInit *somTD_RMDeviceCollection_somDefaultConstCopyInit;
typedef void   SOMLINK somTP_RMDeviceCollection_somDefaultVCopyInit(RMDeviceCollection *somSelf, 
		som3InitCtrl* ctrl, 
		SOMObject* fromObj);
typedef somTP_RMDeviceCollection_somDefaultVCopyInit *somTD_RMDeviceCollection_somDefaultVCopyInit;
typedef void   SOMLINK somTP_RMDeviceCollection_somDefaultConstVCopyInit(RMDeviceCollection *somSelf, 
		som3InitCtrl* ctrl, 
		SOMObject* fromObj);
typedef somTP_RMDeviceCollection_somDefaultConstVCopyInit *somTD_RMDeviceCollection_somDefaultConstVCopyInit;
typedef RMDeviceCollection*   SOMLINK somTP_RMDeviceCollection_somDefaultConstAssign(RMDeviceCollection *somSelf, 
		som3AssignCtrl* ctrl, 
		SOMObject* fromObj);
typedef somTP_RMDeviceCollection_somDefaultConstAssign *somTD_RMDeviceCollection_somDefaultConstAssign;
typedef RMDeviceCollection*   SOMLINK somTP_RMDeviceCollection_somDefaultVAssign(RMDeviceCollection *somSelf, 
		som3AssignCtrl* ctrl, 
		SOMObject* fromObj);
typedef somTP_RMDeviceCollection_somDefaultVAssign *somTD_RMDeviceCollection_somDefaultVAssign;
typedef RMDeviceCollection*   SOMLINK somTP_RMDeviceCollection_somDefaultConstVAssign(RMDeviceCollection *somSelf, 
		som3AssignCtrl* ctrl, 
		SOMObject* fromObj);
typedef somTP_RMDeviceCollection_somDefaultConstVAssign *somTD_RMDeviceCollection_somDefaultConstVAssign;
typedef void   SOMLINK somTP_RMDeviceCollection_somFree(RMDeviceCollection *somSelf);
typedef somTP_RMDeviceCollection_somFree *somTD_RMDeviceCollection_somFree;
typedef M_RMDeviceCollection*   SOMLINK somTP_RMDeviceCollection_somGetClass(RMDeviceCollection *somSelf);
typedef somTP_RMDeviceCollection_somGetClass *somTD_RMDeviceCollection_somGetClass;
typedef string   SOMLINK somTP_RMDeviceCollection_somGetClassName(RMDeviceCollection *somSelf);
typedef somTP_RMDeviceCollection_somGetClassName *somTD_RMDeviceCollection_somGetClassName;
typedef long   SOMLINK somTP_RMDeviceCollection_somGetSize(RMDeviceCollection *somSelf);
typedef somTP_RMDeviceCollection_somGetSize *somTD_RMDeviceCollection_somGetSize;
typedef boolean   SOMLINK somTP_RMDeviceCollection_somIsA(RMDeviceCollection *somSelf, 
		SOMClass* aClassObj);
typedef somTP_RMDeviceCollection_somIsA *somTD_RMDeviceCollection_somIsA;
typedef boolean   SOMLINK somTP_RMDeviceCollection_somIsInstanceOf(RMDeviceCollection *somSelf, 
		SOMClass* aClassObj);
typedef somTP_RMDeviceCollection_somIsInstanceOf *somTD_RMDeviceCollection_somIsInstanceOf;
typedef boolean   SOMLINK somTP_RMDeviceCollection_somRespondsTo(RMDeviceCollection *somSelf, 
		somId mId);
typedef somTP_RMDeviceCollection_somRespondsTo *somTD_RMDeviceCollection_somRespondsTo;
typedef boolean   SOMLINK somTP_RMDeviceCollection_somDispatch(RMDeviceCollection *somSelf, 
		somToken* retValue, 
		somId methodId, 
		va_list ap);
typedef somTP_RMDeviceCollection_somDispatch *somTD_RMDeviceCollection_somDispatch;
typedef boolean   SOMLINK somTP_RMDeviceCollection_somClassDispatch(RMDeviceCollection *somSelf, 
		SOMClass* clsObj, 
		somToken* retValue, 
		somId methodId, 
		va_list ap);
typedef somTP_RMDeviceCollection_somClassDispatch *somTD_RMDeviceCollection_somClassDispatch;
typedef boolean   SOMLINK somTP_RMDeviceCollection_somCastObj(RMDeviceCollection *somSelf, 
		SOMClass* cls);
typedef somTP_RMDeviceCollection_somCastObj *somTD_RMDeviceCollection_somCastObj;
typedef boolean   SOMLINK somTP_RMDeviceCollection_somResetObj(RMDeviceCollection *somSelf);
typedef somTP_RMDeviceCollection_somResetObj *somTD_RMDeviceCollection_somResetObj;
typedef void   SOMLINK somTP_RMDeviceCollection_somDispatchV(RMDeviceCollection *somSelf, 
		somId methodId, 
		somId descriptor, 
		va_list ap);
typedef somTP_RMDeviceCollection_somDispatchV *somTD_RMDeviceCollection_somDispatchV;
typedef long   SOMLINK somTP_RMDeviceCollection_somDispatchL(RMDeviceCollection *somSelf, 
		somId methodId, 
		somId descriptor, 
		va_list ap);
typedef somTP_RMDeviceCollection_somDispatchL *somTD_RMDeviceCollection_somDispatchL;
typedef void*   SOMLINK somTP_RMDeviceCollection_somDispatchA(RMDeviceCollection *somSelf, 
		somId methodId, 
		somId descriptor, 
		va_list ap);
typedef somTP_RMDeviceCollection_somDispatchA *somTD_RMDeviceCollection_somDispatchA;
typedef double   SOMLINK somTP_RMDeviceCollection_somDispatchD(RMDeviceCollection *somSelf, 
		somId methodId, 
		somId descriptor, 
		va_list ap);
typedef somTP_RMDeviceCollection_somDispatchD *somTD_RMDeviceCollection_somDispatchD;
typedef SOMObject*   SOMLINK somTP_RMDeviceCollection_somPrintSelf(RMDeviceCollection *somSelf);
typedef somTP_RMDeviceCollection_somPrintSelf *somTD_RMDeviceCollection_somPrintSelf;
typedef void   SOMLINK somTP_RMDeviceCollection_somDumpSelf(RMDeviceCollection *somSelf, 
		long level);
typedef somTP_RMDeviceCollection_somDumpSelf *somTD_RMDeviceCollection_somDumpSelf;
typedef void   SOMLINK somTP_RMDeviceCollection_somDumpSelfInt(RMDeviceCollection *somSelf, 
		long level);
typedef somTP_RMDeviceCollection_somDumpSelfInt *somTD_RMDeviceCollection_somDumpSelfInt;
}

#endif /* RMDeviceCollection_API */


/*
 * -- This emitter treats Method Tokens as Thunks by default.
 * -- Use the sc modifier "nothunks" to change this default
 */
#undef somresolve_
#define somresolve_(obj,mToken) ((somMethodProc*)((void)obj, mToken))

/*
 * -- The C++ Wrapper Class for RMDeviceCollection
 */
class RMDeviceCollection : public somf_THashTable
{
public:

// RMDeviceCollection::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 (!_RMDeviceCollection) RMDeviceCollectionNewClass(RMDeviceCollection_MajorVersion,RMDeviceCollection_MinorVersion);
   return (void*)
      SOM_Resolve(_RMDeviceCollection,SOMClass,somNewNoInit)
         ((SOMClass *)((void*)_RMDeviceCollection));
}

// RMDeviceCollection::delete uses somDestruct.
void operator delete(void * obj)
{
   if (obj && *(void**)obj) {
      SOM_Resolve(obj,SOMObject,somFree)
         ((SOMObject*)obj);
   }
}

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

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

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

#ifdef __IBMCPP__
#pragma info(nocnv,nopar)
#endif
RMDeviceCollection(const RMDeviceCollection* fromObj)
{
   if (*(void**)this != 
       ((somParentMtabStructPtr)
        (RMDeviceCollectionCClassData.parentMtab))->mtab)
      return;
   ((SOMObject*)((void*)this))->somDefaultConstCopyInit(0,((SOMObject*)((void*)fromObj)));
}
#ifdef __IBMCPP__
#pragma info(restore)
#endif


/* method: addRMDevice */
RMDeviceObject*   addRMDevice(Environment *ev, 
		long key, 
		long idVendor, 
		long idProduct)
{
   return SOM_ResolveD(this,RMDeviceCollection,RMDeviceCollection,addRMDevice)
	(this, ev,key,idVendor,idProduct);
}


/* method: findRMDevice */
RMDeviceObject*   findRMDevice(Environment *ev, 
		long key)
{
   return SOM_ResolveD(this,RMDeviceCollection,RMDeviceCollection,findRMDevice)
	(this, ev,key);
}


/* method: deleteRMDevice */
void   deleteRMDevice(Environment *ev, 
		long key)
{
   SOM_ResolveD(this,RMDeviceCollection,RMDeviceCollection,deleteRMDevice)
	(this, ev,key);
}


/*
 * Reintroduce inherited methods
 */

/* method: somfTHashTableInitFLLL */
somf_THashTable*   somfTHashTableInitFLLL(Environment *ev, 
		somf_MCollectible_somf_MCollectibleCompareFn testfn, 
		long tablesize, 
		long rate, 
		long threshold)
{
/*
 *  Initializes the new hash table.
 */
   return SOM_ResolveD(this,RMDeviceCollection,somf_THashTable,somfTHashTableInitFLLL)
	(this, ev,testfn,tablesize,rate,threshold);
}


/* method: somfTHashTableInitFLL */
somf_THashTable*   somfTHashTableInitFLL(Environment *ev, 
		somf_MCollectible_somf_MCollectibleCompareFn testfn, 
		long tablesize, 
		long rate)
{
/*
 *  Initializes the new hash table.
 */
   return SOM_ResolveD(this,RMDeviceCollection,somf_THashTable,somfTHashTableInitFLL)
	(this, ev,testfn,tablesize,rate);
}


/* method: somfTHashTableInitFL */
somf_THashTable*   somfTHashTableInitFL(Environment *ev, 
		somf_MCollectible_somf_MCollectibleCompareFn testfn, 
		long tablesize)
{
/*
 *  Initializes the new hash table.
 */
   return SOM_ResolveD(this,RMDeviceCollection,somf_THashTable,somfTHashTableInitFL)
	(this, ev,testfn,tablesize);
}


/* method: somfTHashTableInitH */
somf_THashTable*   somfTHashTableInitH(Environment *ev, 
		somf_THashTable* h)
{
/*
 *  Initializes the new hash table.
 */
   return SOM_ResolveD(this,RMDeviceCollection,somf_THashTable,somfTHashTableInitH)
	(this, ev,h);
}


/* method: somfAssign */
void   somfAssign(Environment *ev, 
		somf_THashTable* source)
{
/*
 *  Assign the instance of this equal to the instance of source.
 */
   SOM_ResolveD(this,RMDeviceCollection,somf_THashTable,somfAssign)
	(this, ev,source);
}


/* method: somfCount */
long   somfCount(Environment *ev)
{
/*
 *  Return the number of objects in this.
 */
   return SOM_ResolveD(this,RMDeviceCollection,somf_THashTable,somfCount)
	(this, ev);
}


/* method: somfRemove */
somf_MCollectible*   somfRemove(Environment *ev, 
		somf_MCollectible* key)
{
/*
 *  Remove obj from this.  Return the object which was actually removed
 *  (which if you are using an IsSame test function may not be the same
 *  as the object passed in only "equal").
 */
   return SOM_ResolveD(this,RMDeviceCollection,somf_THashTable,somfRemove)
	(this, ev,key);
}


/* method: somfDelete */
somf_MCollectible*   somfDelete(Environment *ev, 
		somf_MCollectible* key)
{
/*
 *  Remove key from this and deallocate the storage that these objects might
 *  have owned (that is, the destructor function is called for each object
 *  in the collection).  Return the object which was actually removed (which
 *  if you are using an IsSame test function may not be the same as the object
 *  passed in only "equal").
 */
   return SOM_ResolveD(this,RMDeviceCollection,somf_THashTable,somfDelete)
	(this, ev,key);
}


/* method: somfMember */
somf_MCollectible*   somfMember(Environment *ev, 
		somf_MCollectible* key)
{
/*
 *  Each object in this is compared to obj using the function testFn.  Return the
 *  object for which testFn returned TRUE.  Return SOMF_NIL if not object was found.
 */
   return SOM_ResolveD(this,RMDeviceCollection,somf_THashTable,somfMember)
	(this, ev,key);
}


/* method: somfRemoveAll */
void   somfRemoveAll(Environment *ev)
{
/*
 *  Remove all of the objects from this.
 */
   SOM_ResolveD(this,RMDeviceCollection,somf_THashTable,somfRemoveAll)
	(this, ev);
}


/* method: somfDeleteAll */
void   somfDeleteAll(Environment *ev)
{
/*
 *  Remove all of the objects from this and deallocate the storage that these
 *  objects might have owned (that is, the destructor function is called
 *  for each object in the collection).
 */
   SOM_ResolveD(this,RMDeviceCollection,somf_THashTable,somfDeleteAll)
	(this, ev);
}


/* method: somfDeleteAllKeys */
void   somfDeleteAllKeys(Environment *ev)
{
/*
 *  Remove all of the keys from this and deallocate the storage that these
 *  objects might have owned (that is, the destructor function is called
 *  for each object in the collection).
 */
   SOM_ResolveD(this,RMDeviceCollection,somf_THashTable,somfDeleteAllKeys)
	(this, ev);
}


/* method: somfDeleteAllValues */
void   somfDeleteAllValues(Environment *ev)
{
/*
 *  Remove all of the values from this and deallocate the storage that these
 *  objects might have owned (that is, the destructor function is called
 *  for each object in the collection).
 */
   SOM_ResolveD(this,RMDeviceCollection,somf_THashTable,somfDeleteAllValues)
	(this, ev);
}


/* method: somfAddMMB */
somf_MCollectible*   somfAddMMB(Environment *ev, 
		somf_MCollectible* key, 
		somf_MCollectible* value, 
		boolean replace)
{
/*
 *  Add key and value to this.  If replace = TRUE, replace a copy if it already
 *  exists.
 */
   return SOM_ResolveD(this,RMDeviceCollection,somf_THashTable,somfAddMMB)
	(this, ev,key,value,replace);
}


/* method: somfAddMM */
somf_MCollectible*   somfAddMM(Environment *ev, 
		somf_MCollectible* key, 
		somf_MCollectible* value)
{
/*
 *  Add key and value to this.  Replace a copy if it already exists.
 */
   return SOM_ResolveD(this,RMDeviceCollection,somf_THashTable,somfAddMM)
	(this, ev,key,value);
}


/* method: somfGrow */
void   somfGrow(Environment *ev)
{
/*
 *  Grow the Hash Table
 */
   SOM_ResolveD(this,RMDeviceCollection,somf_THashTable,somfGrow)
	(this, ev);
}


/* method: somfRetrieve */
somf_MCollectible*   somfRetrieve(Environment *ev, 
		somf_MCollectible* key)
{
/*
 *  Retrieve and return the value associated with key.
 */
   return SOM_ResolveD(this,RMDeviceCollection,somf_THashTable,somfRetrieve)
	(this, ev,key);
}


/* method: somfSetGrowthRate */
void   somfSetGrowthRate(Environment *ev, 
		long rate)
{
/*
 *  Set the growth rate of the hash table.
 */
   SOM_ResolveD(this,RMDeviceCollection,somf_THashTable,somfSetGrowthRate)
	(this, ev,rate);
}


/* method: somfSetRehashThreshold */
void   somfSetRehashThreshold(Environment *ev, 
		long threshold)
{
/*
 *  Set the rehash threshold of the hash table.
 */
   SOM_ResolveD(this,RMDeviceCollection,somf_THashTable,somfSetRehashThreshold)
	(this, ev,threshold);
}


/* method: somfGetGrowthRate */
long   somfGetGrowthRate(Environment *ev)
{
/*
 *  Return the growth rate of the hash table.
 */
   return SOM_ResolveD(this,RMDeviceCollection,somf_THashTable,somfGetGrowthRate)
	(this, ev);
}


/* method: somfGetRehashThreshold */
long   somfGetRehashThreshold(Environment *ev)
{
/*
 *  Return the rehash threshold of the hash table.
 */
   return SOM_ResolveD(this,RMDeviceCollection,somf_THashTable,somfGetRehashThreshold)
	(this, ev);
}


/* method: somfSetHashFunction */
void   somfSetHashFunction(Environment *ev, 
		somf_MCollectible_somf_MCollectibleHashFn fn)
{
/*
 *  Set the hash function to fn.
 */
   SOM_ResolveD(this,RMDeviceCollection,somf_THashTable,somfSetHashFunction)
	(this, ev,fn);
}


/* method: somfGetHashFunction */
somf_MCollectible_somf_MCollectibleHashFn   somfGetHashFunction(Environment *ev)
{
/*
 *  Return the hash function.
 */
   return SOM_ResolveD(this,RMDeviceCollection,somf_THashTable,somfGetHashFunction)
	(this, ev);
}


/* method: somInit */
void   somInit()
{
   SOM_ResolveD(this,RMDeviceCollection,SOMObject,somInit)
	(this);
}


/* method: somUninit */
void   somUninit()
{
   SOM_ResolveD(this,RMDeviceCollection,SOMObject,somUninit)
	(this);
}


/* method: somfClone */
somf_MCollectible*   somfClone(Environment *ev)
{
/*
 *  somfClone provides a general function for creating a new instance of this.
 */
   return SOM_ResolveD(this,RMDeviceCollection,somf_MCollectible,somfClone)
	(this, ev);
}


/* method: somfClonePointer */
somf_MCollectible*   somfClonePointer(Environment *ev, 
		somf_MCollectible* clonee)
{
/*
 *  somfClonePointer returns a pointer to a Clone
 */
   return SOM_ResolveD(this,RMDeviceCollection,somf_MCollectible,somfClonePointer)
	(this, ev,clonee);
}


/* method: somfHash */
long   somfHash(Environment *ev)
{
/*
 *  somfHash returns a value suitable for use as a hashing probe for this.
 *  The default function will simply return the address of the object.
 *  The default function is almost certainly not adequate if you are overriding
 *  somfIsEqual because you need to make sure that all objects that "are equal"
 *  to each other return the same hash value.  For example, a TText object would
 *  return a hash value computed using the characters in the string instead of
 *  the address of the string.
 */
   return SOM_ResolveD(this,RMDeviceCollection,somf_MCollectible,somfHash)
	(this, ev);
}


/* method: somfIsEqual */
boolean   somfIsEqual(Environment *ev, 
		somf_MCollectible* obj)
{
/*
 *  somfIsEqual returns TRUE if obj is isomorphic to this.  The default function
 *  will give you a nasty message.  For example, the somfIsEqual method
 *  for TText objects will do a string comparison.  All of the utility classes
 *  allow you to specify what methods to use when comparing objects for
 *  insertion, deletion, etc.
 */
   return SOM_ResolveD(this,RMDeviceCollection,somf_MCollectible,somfIsEqual)
	(this, ev,obj);
}


/* method: somfIsSame */
boolean   somfIsSame(Environment *ev, 
		somf_MCollectible* obj)
{
/*
 *  The default function for somfIsSame is a pointer comparison
 */
   return SOM_ResolveD(this,RMDeviceCollection,somf_MCollectible,somfIsSame)
	(this, ev,obj);
}


/* method: somfIsNotEqual */
boolean   somfIsNotEqual(Environment *ev, 
		somf_MCollectible* obj)
{
/*
 *  somfIsNotEqual returns TRUE if obj is NOT isomorphic to this.  It uses
 *  somfIsEqual, so overriding somfIsEqual will handle the logic of somfIsNotEqual too.
 */
   return SOM_ResolveD(this,RMDeviceCollection,somf_MCollectible,somfIsNotEqual)
	(this, ev,obj);
}


/* 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_ResolveD(this,RMDeviceCollection,SOMObject,somDefaultInit)
	(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_ResolveD(this,RMDeviceCollection,SOMObject,somDestruct)
	(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_ResolveD(this,RMDeviceCollection,SOMObject,somDefaultCopyInit)
	(this,ctrl,fromObj);
}


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


/* initializer method: somDefaultConstCopyInit */
void   somDefaultConstCopyInit(som3InitCtrl* ctrl, 
		SOMObject* fromObj)
{
/*
 *  A default copy constructor that uses a const fromObj.
 */
   SOM_ResolveD(this,RMDeviceCollection,SOMObject,somDefaultConstCopyInit)
	(this,ctrl,fromObj);
}


/* initializer method: somDefaultVCopyInit */
void   somDefaultVCopyInit(som3InitCtrl* ctrl, 
		SOMObject* fromObj)
{
/*
 *  A default copy constructor that uses a volatile fromObj.
 */
   SOM_ResolveD(this,RMDeviceCollection,SOMObject,somDefaultVCopyInit)
	(this,ctrl,fromObj);
}


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


/* method: somDefaultConstAssign */
RMDeviceCollection*  somDefaultConstAssign(som3AssignCtrl* ctrl, 
		SOMObject* fromObj)
{
/*
 *  A default assignment operator that uses a const fromObj.
 */
   return SOM_ResolveD(this,RMDeviceCollection,SOMObject,somDefaultConstAssign)
	(this,ctrl,fromObj);
}


/* method: somDefaultVAssign */
RMDeviceCollection*  somDefaultVAssign(som3AssignCtrl* ctrl, 
		SOMObject* fromObj)
{
/*
 *  A default assignment operator that uses a volatile fromObj.
 */
   return SOM_ResolveD(this,RMDeviceCollection,SOMObject,somDefaultVAssign)
	(this,ctrl,fromObj);
}


/* method: somDefaultConstVAssign */
RMDeviceCollection*  somDefaultConstVAssign(som3AssignCtrl* ctrl, 
		SOMObject* fromObj)
{
/*
 *  A default assignment operator that uses a const volatile fromObj.
 */
   return SOM_ResolveD(this,RMDeviceCollection,SOMObject,somDefaultConstVAssign)
	(this,ctrl,fromObj);
}


/* method: somFree */
void   somFree()
{
/*
 *  Use as directed by framework implementations.
 */
   SOM_ResolveD(this,RMDeviceCollection,SOMObject,somFree)
	(this);
}


/* method: somGetClass */
M_RMDeviceCollection*  somGetClass()
{
/*
 *  Return the receiver's class.
 */
   return SOM_ResolveD(this,RMDeviceCollection,SOMObject,somGetClass)
	(this);
}


/* method: somGetClassName */
string   somGetClassName()
{
/*
 *  Return the name of the receiver's class.
 */
   return SOM_ResolveD(this,RMDeviceCollection,SOMObject,somGetClassName)
	(this);
}


/* method: somGetSize */
long   somGetSize()
{
/*
 *  Return the size of the receiver.
 */
   return SOM_ResolveD(this,RMDeviceCollection,SOMObject,somGetSize)
	(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_ResolveD(this,RMDeviceCollection,SOMObject,somIsA)
	(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_ResolveD(this,RMDeviceCollection,SOMObject,somIsInstanceOf)
	(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_ResolveD(this,RMDeviceCollection,SOMObject,somRespondsTo)
	(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.
 */
/* the va_list invocation form */
boolean   RMDeviceCollection_somDispatch(somToken* retValue, 
		somId methodId, 
		va_list ap)
{return SOM_ResolveD(this,RMDeviceCollection,SOMObject,somDispatch)
	(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.
 */
   va_list ap;
   va_start(ap, methodId);
   boolean __somResult = 
      SOM_ResolveD(this,RMDeviceCollection,SOMObject,somDispatch)
	(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   RMDeviceCollection_somClassDispatch(SOMClass* clsObj, 
		somToken* retValue, 
		somId methodId, 
		va_list ap)
{return SOM_ResolveD(this,RMDeviceCollection,SOMObject,somClassDispatch)
	(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_ResolveD(this,RMDeviceCollection,SOMObject,somClassDispatch)
	(this,clsObj,retValue,methodId,ap);
   va_end(ap);
   return __somResult;
}


/* method: somCastObj */
boolean   somCastObj(SOMClass* cls)
{
/*
 *  cast the receiving object to cls (which must be an ancestor of the
 *  objects true class. Returns true on success.
 */
   return SOM_ResolveD(this,RMDeviceCollection,SOMObject,somCastObj)
	(this,cls);
}


/* method: somResetObj */
boolean   somResetObj()
{
/*
 *  reset an object to its true class. Returns true always.
 */
   return SOM_ResolveD(this,RMDeviceCollection,SOMObject,somResetObj)
	(this);
}


/* va_list method: somDispatchV */

/*
 *  Obsolete. Use somDispatch instead.
 */
/* the va_list invocation form */
void   RMDeviceCollection_somDispatchV(somId methodId, 
		somId descriptor, 
		va_list ap)
{   SOM_ResolveD(this,RMDeviceCollection,SOMObject,somDispatchV)
	(this,methodId,descriptor,ap);
}

/* the varargs invocation form */
void   somDispatchV(somId methodId, 
		somId descriptor, 
		...)
{
/*
 *  Obsolete. Use somDispatch instead.
 */
   va_list ap;
   va_start(ap, descriptor);
   SOM_ResolveD(this,RMDeviceCollection,SOMObject,somDispatchV)
	(this,methodId,descriptor,ap);
   va_end(ap);
}


/* va_list method: somDispatchL */

/*
 *  Obsolete. Use somDispatch instead.
 */
/* the va_list invocation form */
long   RMDeviceCollection_somDispatchL(somId methodId, 
		somId descriptor, 
		va_list ap)
{return SOM_ResolveD(this,RMDeviceCollection,SOMObject,somDispatchL)
	(this,methodId,descriptor,ap);
}

/* the varargs invocation form */
long   somDispatchL(somId methodId, 
		somId descriptor, 
		...)
{
/*
 *  Obsolete. Use somDispatch instead.
 */
   va_list ap;
   va_start(ap, descriptor);
   long __somResult = 
      SOM_ResolveD(this,RMDeviceCollection,SOMObject,somDispatchL)
	(this,methodId,descriptor,ap);
   va_end(ap);
   return __somResult;
}


/* va_list method: somDispatchA */

/*
 *  Obsolete. Use somDispatch instead.
 */
/* the va_list invocation form */
void*   RMDeviceCollection_somDispatchA(somId methodId, 
		somId descriptor, 
		va_list ap)
{return SOM_ResolveD(this,RMDeviceCollection,SOMObject,somDispatchA)
	(this,methodId,descriptor,ap);
}

/* the varargs invocation form */
void*   somDispatchA(somId methodId, 
		somId descriptor, 
		...)
{
/*
 *  Obsolete. Use somDispatch instead.
 */
   va_list ap;
   va_start(ap, descriptor);
   void* __somResult = 
      SOM_ResolveD(this,RMDeviceCollection,SOMObject,somDispatchA)
	(this,methodId,descriptor,ap);
   va_end(ap);
   return __somResult;
}


/* va_list method: somDispatchD */

/*
 *  Obsolete. Use somDispatch instead.
 */
/* the va_list invocation form */
double   RMDeviceCollection_somDispatchD(somId methodId, 
		somId descriptor, 
		va_list ap)
{return SOM_ResolveD(this,RMDeviceCollection,SOMObject,somDispatchD)
	(this,methodId,descriptor,ap);
}

/* the varargs invocation form */
double   somDispatchD(somId methodId, 
		somId descriptor, 
		...)
{
/*
 *  Obsolete. Use somDispatch instead.
 */
   va_list ap;
   va_start(ap, descriptor);
   double __somResult = 
      SOM_ResolveD(this,RMDeviceCollection,SOMObject,somDispatchD)
	(this,methodId,descriptor,ap);
   va_end(ap);
   return __somResult;
}


/* method: somPrintSelf */
SOMObject*   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_ResolveD(this,RMDeviceCollection,SOMObject,somPrintSelf)
	(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_ResolveD(this,RMDeviceCollection,SOMObject,somDumpSelf)
	(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_ResolveD(this,RMDeviceCollection,SOMObject,somDumpSelfInt)
	(this,level);
}



};   /* RMDeviceCollection */



#endif       /* SOM_RMDeviceCollection_xh */

#ifndef SOM_M_RMDeviceCollection_xh
#define SOM_M_RMDeviceCollection_xh

class M_RMDeviceCollection;

#define M_RMDeviceCollection_MajorVersion 2
#define M_RMDeviceCollection_MinorVersion 1

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

/* C++ parent defs */
#ifndef SOM_SOMClass_xh
#include <somcls.xh>
#endif

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

/*
 * Start of bindings for IDL types
 */


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

/*
 * -- M_RMDeviceCollection is a metaclass for RMDeviceCollection. Make sure RMDeviceCollection is known.
 */
class RMDeviceCollection;


/* A procedure to create the M_RMDeviceCollection Class */
SOMEXTERN SOMClass * SOMLINK M_RMDeviceCollectionNewClass(
		integer4 majorVersion,
		integer4 minorVersion);

/* The API to the M_RMDeviceCollection class object, and the methods it introduces. */
SOMEXTERN struct M_RMDeviceCollectionClassDataStructure {
	SOMClass *classObject;
} SOMDLINK M_RMDeviceCollectionClassData;
#define _M_RMDeviceCollection M_RMDeviceCollectionClassData.classObject

/* The API to parentMtabs for M_RMDeviceCollection, and the instance data it introduces. */
SOMEXTERN struct M_RMDeviceCollectionCClassDataStructure {
	somMethodTabs parentMtab;
	somDToken              instanceDataToken;
} SOMDLINK M_RMDeviceCollectionCClassData;

/*
 * -- Typedefs for M_RMDeviceCollection Method Procedures
 */
SOMEXTERN {

/*
 * -- Typedefs for Reintroduced Wrapper Methods
 */
typedef long   SOMLINK somTP_M_RMDeviceCollection__get_somDataAlignment(M_RMDeviceCollection *somSelf);
typedef somTP_M_RMDeviceCollection__get_somDataAlignment *somTD_M_RMDeviceCollection__get_somDataAlignment;
typedef SOMClass_somOffsets   SOMLINK somTP_M_RMDeviceCollection__get_somInstanceDataOffsets(M_RMDeviceCollection *somSelf);
typedef somTP_M_RMDeviceCollection__get_somInstanceDataOffsets *somTD_M_RMDeviceCollection__get_somInstanceDataOffsets;
typedef SOMClass_SOMClassSequence   SOMLINK somTP_M_RMDeviceCollection__get_somDirectInitClasses(M_RMDeviceCollection *somSelf);
typedef somTP_M_RMDeviceCollection__get_somDirectInitClasses *somTD_M_RMDeviceCollection__get_somDirectInitClasses;
typedef RMDeviceCollection*   SOMLINK somTP_M_RMDeviceCollection_somNew(M_RMDeviceCollection *somSelf);
typedef somTP_M_RMDeviceCollection_somNew *somTD_M_RMDeviceCollection_somNew;
typedef SOMObject*   SOMLINK somTP_M_RMDeviceCollection_somNewNoInit(M_RMDeviceCollection *somSelf);
typedef somTP_M_RMDeviceCollection_somNewNoInit *somTD_M_RMDeviceCollection_somNewNoInit;
typedef SOMObject*   SOMLINK somTP_M_RMDeviceCollection_somRenew(M_RMDeviceCollection *somSelf, 
		void* obj);
typedef somTP_M_RMDeviceCollection_somRenew *somTD_M_RMDeviceCollection_somRenew;
typedef SOMObject*   SOMLINK somTP_M_RMDeviceCollection_somRenewNoInit(M_RMDeviceCollection *somSelf, 
		void* obj);
typedef somTP_M_RMDeviceCollection_somRenewNoInit *somTD_M_RMDeviceCollection_somRenewNoInit;
typedef SOMObject*   SOMLINK somTP_M_RMDeviceCollection_somRenewNoZero(M_RMDeviceCollection *somSelf, 
		void* obj);
typedef somTP_M_RMDeviceCollection_somRenewNoZero *somTD_M_RMDeviceCollection_somRenewNoZero;
typedef SOMObject*   SOMLINK somTP_M_RMDeviceCollection_somRenewNoInitNoZero(M_RMDeviceCollection *somSelf, 
		void* obj);
typedef somTP_M_RMDeviceCollection_somRenewNoInitNoZero *somTD_M_RMDeviceCollection_somRenewNoInitNoZero;
typedef somToken   SOMLINK somTP_M_RMDeviceCollection_somAllocate(M_RMDeviceCollection *somSelf, 
		long size);
typedef somTP_M_RMDeviceCollection_somAllocate *somTD_M_RMDeviceCollection_somAllocate;
typedef void   SOMLINK somTP_M_RMDeviceCollection_somDeallocate(M_RMDeviceCollection *somSelf, 
		somToken memptr);
typedef somTP_M_RMDeviceCollection_somDeallocate *somTD_M_RMDeviceCollection_somDeallocate;
typedef void   SOMLINK somTP_M_RMDeviceCollection_somInitClass(M_RMDeviceCollection *somSelf, 
		string className, 
		SOMClass* parentClass, 
		long dataSize, 
		long maxStaticMethods, 
		long majorVersion, 
		long minorVersion);
typedef somTP_M_RMDeviceCollection_somInitClass *somTD_M_RMDeviceCollection_somInitClass;
typedef void   SOMLINK somTP_M_RMDeviceCollection_somInitMIClass(M_RMDeviceCollection *somSelf, 
		long inherit_vars, 
		string className, 
		SOMClass_SOMClassSequence* parentClasses, 
		long dataSize, 
		long dataAlignment, 
		long maxStaticMethods, 
		long majorVersion, 
		long minorVersion);
typedef somTP_M_RMDeviceCollection_somInitMIClass *somTD_M_RMDeviceCollection_somInitMIClass;
typedef somMToken   SOMLINK somTP_M_RMDeviceCollection_somAddStaticMethod(M_RMDeviceCollection *somSelf, 
		somId methodId, 
		somId methodDescriptor, 
		somMethodPtr method, 
		somMethodPtr redispatchStub, 
		somMethodPtr applyStub);
typedef somTP_M_RMDeviceCollection_somAddStaticMethod *somTD_M_RMDeviceCollection_somAddStaticMethod;
typedef void   SOMLINK somTP_M_RMDeviceCollection_somAddDynamicMethod(M_RMDeviceCollection *somSelf, 
		somId methodId, 
		somId methodDescriptor, 
		somMethodPtr method, 
		somMethodPtr applyStub);
typedef somTP_M_RMDeviceCollection_somAddDynamicMethod *somTD_M_RMDeviceCollection_somAddDynamicMethod;
typedef void   SOMLINK somTP_M_RMDeviceCollection_somOverrideSMethod(M_RMDeviceCollection *somSelf, 
		somId methodId, 
		somMethodPtr method);
typedef somTP_M_RMDeviceCollection_somOverrideSMethod *somTD_M_RMDeviceCollection_somOverrideSMethod;
typedef void   SOMLINK somTP_M_RMDeviceCollection_somClassReady(M_RMDeviceCollection *somSelf);
typedef somTP_M_RMDeviceCollection_somClassReady *somTD_M_RMDeviceCollection_somClassReady;
typedef somMethodPtr   SOMLINK somTP_M_RMDeviceCollection_somGetApplyStub(M_RMDeviceCollection *somSelf, 
		somId methodId);
typedef somTP_M_RMDeviceCollection_somGetApplyStub *somTD_M_RMDeviceCollection_somGetApplyStub;
typedef somClassDataStructure*   SOMLINK somTP_M_RMDeviceCollection_somGetClassData(M_RMDeviceCollection *somSelf);
typedef somTP_M_RMDeviceCollection_somGetClassData *somTD_M_RMDeviceCollection_somGetClassData;
typedef void   SOMLINK somTP_M_RMDeviceCollection_somSetClassData(M_RMDeviceCollection *somSelf, 
		somClassDataStructure* cds);
typedef somTP_M_RMDeviceCollection_somSetClassData *somTD_M_RMDeviceCollection_somSetClassData;
typedef somMethodTab*   SOMLINK somTP_M_RMDeviceCollection_somGetClassMtab(M_RMDeviceCollection *somSelf);
typedef somTP_M_RMDeviceCollection_somGetClassMtab *somTD_M_RMDeviceCollection_somGetClassMtab;
typedef long   SOMLINK somTP_M_RMDeviceCollection_somGetInstanceOffset(M_RMDeviceCollection *somSelf);
typedef somTP_M_RMDeviceCollection_somGetInstanceOffset *somTD_M_RMDeviceCollection_somGetInstanceOffset;
typedef long   SOMLINK somTP_M_RMDeviceCollection_somGetInstancePartSize(M_RMDeviceCollection *somSelf);
typedef somTP_M_RMDeviceCollection_somGetInstancePartSize *somTD_M_RMDeviceCollection_somGetInstancePartSize;
typedef long   SOMLINK somTP_M_RMDeviceCollection_somGetInstanceSize(M_RMDeviceCollection *somSelf);
typedef somTP_M_RMDeviceCollection_somGetInstanceSize *somTD_M_RMDeviceCollection_somGetInstanceSize;
typedef somDToken   SOMLINK somTP_M_RMDeviceCollection_somGetInstanceToken(M_RMDeviceCollection *somSelf);
typedef somTP_M_RMDeviceCollection_somGetInstanceToken *somTD_M_RMDeviceCollection_somGetInstanceToken;
typedef somDToken   SOMLINK somTP_M_RMDeviceCollection_somGetMemberToken(M_RMDeviceCollection *somSelf, 
		long memberOffset, 
		somDToken instanceToken);
typedef somTP_M_RMDeviceCollection_somGetMemberToken *somTD_M_RMDeviceCollection_somGetMemberToken;
typedef boolean   SOMLINK somTP_M_RMDeviceCollection_somGetMethodData(M_RMDeviceCollection *somSelf, 
		somId methodId, 
		somMethodData* md);
typedef somTP_M_RMDeviceCollection_somGetMethodData *somTD_M_RMDeviceCollection_somGetMethodData;
typedef somMethodProc*   SOMLINK somTP_M_RMDeviceCollection_somGetRdStub(M_RMDeviceCollection *somSelf, 
		somId methodId);
typedef somTP_M_RMDeviceCollection_somGetRdStub *somTD_M_RMDeviceCollection_somGetRdStub;
typedef somId   SOMLINK somTP_M_RMDeviceCollection_somGetMethodDescriptor(M_RMDeviceCollection *somSelf, 
		somId methodId);
typedef somTP_M_RMDeviceCollection_somGetMethodDescriptor *somTD_M_RMDeviceCollection_somGetMethodDescriptor;
typedef long   SOMLINK somTP_M_RMDeviceCollection_somGetMethodIndex(M_RMDeviceCollection *somSelf, 
		somId id);
typedef somTP_M_RMDeviceCollection_somGetMethodIndex *somTD_M_RMDeviceCollection_somGetMethodIndex;
typedef somMToken   SOMLINK somTP_M_RMDeviceCollection_somGetMethodToken(M_RMDeviceCollection *somSelf, 
		somId methodId);
typedef somTP_M_RMDeviceCollection_somGetMethodToken *somTD_M_RMDeviceCollection_somGetMethodToken;
typedef string   SOMLINK somTP_M_RMDeviceCollection_somGetName(M_RMDeviceCollection *somSelf);
typedef somTP_M_RMDeviceCollection_somGetName *somTD_M_RMDeviceCollection_somGetName;
typedef boolean   SOMLINK somTP_M_RMDeviceCollection_somGetNthMethodData(M_RMDeviceCollection *somSelf, 
		long n, 
		somMethodData* md);
typedef somTP_M_RMDeviceCollection_somGetNthMethodData *somTD_M_RMDeviceCollection_somGetNthMethodData;
typedef somId   SOMLINK somTP_M_RMDeviceCollection_somGetNthMethodInfo(M_RMDeviceCollection *somSelf, 
		long n, 
		somId* descriptor);
typedef somTP_M_RMDeviceCollection_somGetNthMethodInfo *somTD_M_RMDeviceCollection_somGetNthMethodInfo;
typedef long   SOMLINK somTP_M_RMDeviceCollection_somGetNumMethods(M_RMDeviceCollection *somSelf);
typedef somTP_M_RMDeviceCollection_somGetNumMethods *somTD_M_RMDeviceCollection_somGetNumMethods;
typedef long   SOMLINK somTP_M_RMDeviceCollection_somGetNumStaticMethods(M_RMDeviceCollection *somSelf);
typedef somTP_M_RMDeviceCollection_somGetNumStaticMethods *somTD_M_RMDeviceCollection_somGetNumStaticMethods;
typedef SOMClass*   SOMLINK somTP_M_RMDeviceCollection_somGetParent(M_RMDeviceCollection *somSelf);
typedef somTP_M_RMDeviceCollection_somGetParent *somTD_M_RMDeviceCollection_somGetParent;
typedef SOMClass_SOMClassSequence   SOMLINK somTP_M_RMDeviceCollection_somGetParents(M_RMDeviceCollection *somSelf);
typedef somTP_M_RMDeviceCollection_somGetParents *somTD_M_RMDeviceCollection_somGetParents;
typedef void   SOMLINK somTP_M_RMDeviceCollection_somGetVersionNumbers(M_RMDeviceCollection *somSelf, 
		long* majorVersion, 
		long* minorVersion);
typedef somTP_M_RMDeviceCollection_somGetVersionNumbers *somTD_M_RMDeviceCollection_somGetVersionNumbers;
typedef boolean   SOMLINK somTP_M_RMDeviceCollection_somFindMethod(M_RMDeviceCollection *somSelf, 
		somId methodId, 
		somMethodPtr* m);
typedef somTP_M_RMDeviceCollection_somFindMethod *somTD_M_RMDeviceCollection_somFindMethod;
typedef boolean   SOMLINK somTP_M_RMDeviceCollection_somFindMethodOk(M_RMDeviceCollection *somSelf, 
		somId methodId, 
		somMethodPtr* m);
typedef somTP_M_RMDeviceCollection_somFindMethodOk *somTD_M_RMDeviceCollection_somFindMethodOk;
typedef somMethodPtr   SOMLINK somTP_M_RMDeviceCollection_somFindSMethod(M_RMDeviceCollection *somSelf, 
		somId methodId);
typedef somTP_M_RMDeviceCollection_somFindSMethod *somTD_M_RMDeviceCollection_somFindSMethod;
typedef somMethodPtr   SOMLINK somTP_M_RMDeviceCollection_somFindSMethodOk(M_RMDeviceCollection *somSelf, 
		somId methodId);
typedef somTP_M_RMDeviceCollection_somFindSMethodOk *somTD_M_RMDeviceCollection_somFindSMethodOk;
typedef somMethodPtr   SOMLINK somTP_M_RMDeviceCollection_somLookupMethod(M_RMDeviceCollection *somSelf, 
		somId methodId);
typedef somTP_M_RMDeviceCollection_somLookupMethod *somTD_M_RMDeviceCollection_somLookupMethod;
typedef boolean   SOMLINK somTP_M_RMDeviceCollection_somCheckVersion(M_RMDeviceCollection *somSelf, 
		long majorVersion, 
		long minorVersion);
typedef somTP_M_RMDeviceCollection_somCheckVersion *somTD_M_RMDeviceCollection_somCheckVersion;
typedef boolean   SOMLINK somTP_M_RMDeviceCollection_somDescendedFrom(M_RMDeviceCollection *somSelf, 
		SOMClass* aClassObj);
typedef somTP_M_RMDeviceCollection_somDescendedFrom *somTD_M_RMDeviceCollection_somDescendedFrom;
typedef boolean   SOMLINK somTP_M_RMDeviceCollection_somSupportsMethod(M_RMDeviceCollection *somSelf, 
		somId mId);
typedef somTP_M_RMDeviceCollection_somSupportsMethod *somTD_M_RMDeviceCollection_somSupportsMethod;
typedef somMethodPtr   SOMLINK somTP_M_RMDeviceCollection_somDefinedMethod(M_RMDeviceCollection *somSelf, 
		somMToken method);
typedef somTP_M_RMDeviceCollection_somDefinedMethod *somTD_M_RMDeviceCollection_somDefinedMethod;
typedef void   SOMLINK somTP_M_RMDeviceCollection_somOverrideMtab(M_RMDeviceCollection *somSelf);
typedef somTP_M_RMDeviceCollection_somOverrideMtab *somTD_M_RMDeviceCollection_somOverrideMtab;
typedef void   SOMLINK somTP_M_RMDeviceCollection_somDefaultInit(M_RMDeviceCollection *somSelf, 
		som3InitCtrl* ctrl);
typedef somTP_M_RMDeviceCollection_somDefaultInit *somTD_M_RMDeviceCollection_somDefaultInit;
typedef void   SOMLINK somTP_M_RMDeviceCollection_somDestruct(M_RMDeviceCollection *somSelf, 
		octet doFree, 
		som3DestructCtrl* ctrl);
typedef somTP_M_RMDeviceCollection_somDestruct *somTD_M_RMDeviceCollection_somDestruct;
typedef void   SOMLINK somTP_M_RMDeviceCollection_somDefaultCopyInit(M_RMDeviceCollection *somSelf, 
		som3InitCtrl* ctrl, 
		SOMObject* fromObj);
typedef somTP_M_RMDeviceCollection_somDefaultCopyInit *somTD_M_RMDeviceCollection_somDefaultCopyInit;
typedef M_RMDeviceCollection*   SOMLINK somTP_M_RMDeviceCollection_somDefaultAssign(M_RMDeviceCollection *somSelf, 
		som3AssignCtrl* ctrl, 
		SOMObject* fromObj);
typedef somTP_M_RMDeviceCollection_somDefaultAssign *somTD_M_RMDeviceCollection_somDefaultAssign;
typedef void   SOMLINK somTP_M_RMDeviceCollection_somDefaultConstCopyInit(M_RMDeviceCollection *somSelf, 
		som3InitCtrl* ctrl, 
		SOMObject* fromObj);
typedef somTP_M_RMDeviceCollection_somDefaultConstCopyInit *somTD_M_RMDeviceCollection_somDefaultConstCopyInit;
typedef void   SOMLINK somTP_M_RMDeviceCollection_somDefaultVCopyInit(M_RMDeviceCollection *somSelf, 
		som3InitCtrl* ctrl, 
		SOMObject* fromObj);
typedef somTP_M_RMDeviceCollection_somDefaultVCopyInit *somTD_M_RMDeviceCollection_somDefaultVCopyInit;
typedef void   SOMLINK somTP_M_RMDeviceCollection_somDefaultConstVCopyInit(M_RMDeviceCollection *somSelf, 
		som3InitCtrl* ctrl, 
		SOMObject* fromObj);
typedef somTP_M_RMDeviceCollection_somDefaultConstVCopyInit *somTD_M_RMDeviceCollection_somDefaultConstVCopyInit;
typedef M_RMDeviceCollection*   SOMLINK somTP_M_RMDeviceCollection_somDefaultConstAssign(M_RMDeviceCollection *somSelf, 
		som3AssignCtrl* ctrl, 
		SOMObject* fromObj);
typedef somTP_M_RMDeviceCollection_somDefaultConstAssign *somTD_M_RMDeviceCollection_somDefaultConstAssign;
typedef M_RMDeviceCollection*   SOMLINK somTP_M_RMDeviceCollection_somDefaultVAssign(M_RMDeviceCollection *somSelf, 
		som3AssignCtrl* ctrl, 
		SOMObject* fromObj);
typedef somTP_M_RMDeviceCollection_somDefaultVAssign *somTD_M_RMDeviceCollection_somDefaultVAssign;
typedef M_RMDeviceCollection*   SOMLINK somTP_M_RMDeviceCollection_somDefaultConstVAssign(M_RMDeviceCollection *somSelf, 
		som3AssignCtrl* ctrl, 
		SOMObject* fromObj);
typedef somTP_M_RMDeviceCollection_somDefaultConstVAssign *somTD_M_RMDeviceCollection_somDefaultConstVAssign;
typedef void   SOMLINK somTP_M_RMDeviceCollection_somInit(M_RMDeviceCollection *somSelf);
typedef somTP_M_RMDeviceCollection_somInit *somTD_M_RMDeviceCollection_somInit;
typedef void   SOMLINK somTP_M_RMDeviceCollection_somFree(M_RMDeviceCollection *somSelf);
typedef somTP_M_RMDeviceCollection_somFree *somTD_M_RMDeviceCollection_somFree;
typedef void   SOMLINK somTP_M_RMDeviceCollection_somUninit(M_RMDeviceCollection *somSelf);
typedef somTP_M_RMDeviceCollection_somUninit *somTD_M_RMDeviceCollection_somUninit;
typedef SOMClass*   SOMLINK somTP_M_RMDeviceCollection_somGetClass(M_RMDeviceCollection *somSelf);
typedef somTP_M_RMDeviceCollection_somGetClass *somTD_M_RMDeviceCollection_somGetClass;
typedef string   SOMLINK somTP_M_RMDeviceCollection_somGetClassName(M_RMDeviceCollection *somSelf);
typedef somTP_M_RMDeviceCollection_somGetClassName *somTD_M_RMDeviceCollection_somGetClassName;
typedef long   SOMLINK somTP_M_RMDeviceCollection_somGetSize(M_RMDeviceCollection *somSelf);
typedef somTP_M_RMDeviceCollection_somGetSize *somTD_M_RMDeviceCollection_somGetSize;
typedef boolean   SOMLINK somTP_M_RMDeviceCollection_somIsA(M_RMDeviceCollection *somSelf, 
		SOMClass* aClassObj);
typedef somTP_M_RMDeviceCollection_somIsA *somTD_M_RMDeviceCollection_somIsA;
typedef boolean   SOMLINK somTP_M_RMDeviceCollection_somIsInstanceOf(M_RMDeviceCollection *somSelf, 
		SOMClass* aClassObj);
typedef somTP_M_RMDeviceCollection_somIsInstanceOf *somTD_M_RMDeviceCollection_somIsInstanceOf;
typedef boolean   SOMLINK somTP_M_RMDeviceCollection_somRespondsTo(M_RMDeviceCollection *somSelf, 
		somId mId);
typedef somTP_M_RMDeviceCollection_somRespondsTo *somTD_M_RMDeviceCollection_somRespondsTo;
typedef boolean   SOMLINK somTP_M_RMDeviceCollection_somDispatch(M_RMDeviceCollection *somSelf, 
		somToken* retValue, 
		somId methodId, 
		va_list ap);
typedef somTP_M_RMDeviceCollection_somDispatch *somTD_M_RMDeviceCollection_somDispatch;
typedef boolean   SOMLINK somTP_M_RMDeviceCollection_somClassDispatch(M_RMDeviceCollection *somSelf, 
		SOMClass* clsObj, 
		somToken* retValue, 
		somId methodId, 
		va_list ap);
typedef somTP_M_RMDeviceCollection_somClassDispatch *somTD_M_RMDeviceCollection_somClassDispatch;
typedef boolean   SOMLINK somTP_M_RMDeviceCollection_somCastObj(M_RMDeviceCollection *somSelf, 
		SOMClass* cls);
typedef somTP_M_RMDeviceCollection_somCastObj *somTD_M_RMDeviceCollection_somCastObj;
typedef boolean   SOMLINK somTP_M_RMDeviceCollection_somResetObj(M_RMDeviceCollection *somSelf);
typedef somTP_M_RMDeviceCollection_somResetObj *somTD_M_RMDeviceCollection_somResetObj;
typedef void   SOMLINK somTP_M_RMDeviceCollection_somDispatchV(M_RMDeviceCollection *somSelf, 
		somId methodId, 
		somId descriptor, 
		va_list ap);
typedef somTP_M_RMDeviceCollection_somDispatchV *somTD_M_RMDeviceCollection_somDispatchV;
typedef long   SOMLINK somTP_M_RMDeviceCollection_somDispatchL(M_RMDeviceCollection *somSelf, 
		somId methodId, 
		somId descriptor, 
		va_list ap);
typedef somTP_M_RMDeviceCollection_somDispatchL *somTD_M_RMDeviceCollection_somDispatchL;
typedef void*   SOMLINK somTP_M_RMDeviceCollection_somDispatchA(M_RMDeviceCollection *somSelf, 
		somId methodId, 
		somId descriptor, 
		va_list ap);
typedef somTP_M_RMDeviceCollection_somDispatchA *somTD_M_RMDeviceCollection_somDispatchA;
typedef double   SOMLINK somTP_M_RMDeviceCollection_somDispatchD(M_RMDeviceCollection *somSelf, 
		somId methodId, 
		somId descriptor, 
		va_list ap);
typedef somTP_M_RMDeviceCollection_somDispatchD *somTD_M_RMDeviceCollection_somDispatchD;
typedef SOMObject*   SOMLINK somTP_M_RMDeviceCollection_somPrintSelf(M_RMDeviceCollection *somSelf);
typedef somTP_M_RMDeviceCollection_somPrintSelf *somTD_M_RMDeviceCollection_somPrintSelf;
typedef void   SOMLINK somTP_M_RMDeviceCollection_somDumpSelf(M_RMDeviceCollection *somSelf, 
		long level);
typedef somTP_M_RMDeviceCollection_somDumpSelf *somTD_M_RMDeviceCollection_somDumpSelf;
typedef void   SOMLINK somTP_M_RMDeviceCollection_somDumpSelfInt(M_RMDeviceCollection *somSelf, 
		long level);
typedef somTP_M_RMDeviceCollection_somDumpSelfInt *somTD_M_RMDeviceCollection_somDumpSelfInt;
}

#endif /* M_RMDeviceCollection_API */


/*
 * -- This emitter treats Method Tokens as Thunks by default.
 * -- Use the sc modifier "nothunks" to change this default
 */
#undef somresolve_
#define somresolve_(obj,mToken) ((somMethodProc*)((void)obj, mToken))

/*
 * -- The C++ Wrapper Class for M_RMDeviceCollection
 */
class M_RMDeviceCollection : public SOMClass
{
public:

// M_RMDeviceCollection::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 (!_M_RMDeviceCollection) M_RMDeviceCollectionNewClass(M_RMDeviceCollection_MajorVersion,M_RMDeviceCollection_MinorVersion);
   return (void*)
      SOM_Resolve(_M_RMDeviceCollection,SOMClass,somNewNoInit)
         ((SOMClass *)((void*)_M_RMDeviceCollection));
}

// M_RMDeviceCollection::delete uses somDestruct.
void operator delete(void * obj)
{
   if (obj && *(void**)obj) {
      SOM_Resolve(obj,SOMObject,somFree)
         ((SOMObject*)obj);
   }
}

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

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

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

#ifdef __IBMCPP__
#pragma info(nocnv,nopar)
#endif
M_RMDeviceCollection(const M_RMDeviceCollection* fromObj)
{
   if (*(void**)this != 
       ((somParentMtabStructPtr)
        (M_RMDeviceCollectionCClassData.parentMtab))->mtab)
      return;
   ((SOMObject*)((void*)this))->somDefaultConstCopyInit(0,((SOMObject*)((void*)fromObj)));
}
#ifdef __IBMCPP__
#pragma info(restore)
#endif


/*
 * Reintroduce inherited methods
 */

/* method: _get_somDataAlignment */
long   _get_somDataAlignment()
{
/*
 *  The alignment required for the instance data structure
 *  introduced by the receiving class.
 */
   return SOM_ResolveD(this,M_RMDeviceCollection,SOMClass,_get_somDataAlignment)
	(this);
}


/* nonstatic method: _get_somInstanceDataOffsets */
SOMClass_somOffsets   _get_somInstanceDataOffsets()
{
/*
 *  A sequence of the instance data offsets for all classes used in
 *  the derivation of the receiving class (including the receiver).
 */
   return SOM_ResolveD(this,M_RMDeviceCollection,SOMClass,_get_somInstanceDataOffsets)
	(this);
}


/* nonstatic method: _get_somDirectInitClasses */
SOMClass_SOMClassSequence   _get_somDirectInitClasses()
{
/*
 *  The ancestors whose initializers the receiving
 *  class wants to directly invoke.
 */
   return SOM_ResolveD(this,M_RMDeviceCollection,SOMClass,_get_somDirectInitClasses)
	(this);
}


/* method: somNew */
RMDeviceCollection*  somNew()
{
/*
 *  Uses SOMMalloc to allocate storage for a new instance of the
 *  receiving class, and then calls somRenewNoInitNoZero to load the
 *  new object's method table pointer. Then somDefaultInit is called to
 *  initialize the new object.  Note: If the instance is a class object,
 *  somInitMIClass must then be invoked to declare parents and
 *  initialize the class's instance method table. Upon failure, NULL
 *  is returned.
 */
   return SOM_ResolveD(this,M_RMDeviceCollection,SOMClass,somNew)
	(this);
}


/* method: somNewNoInit */
SOMObject*   somNewNoInit()
{
/*
 *  Equivalent to somNew except that somDefaultInit is not called.
 */
   return SOM_ResolveD(this,M_RMDeviceCollection,SOMClass,somNewNoInit)
	(this);
}


/* method: somRenew */
SOMObject*   somRenew(void* obj)
{
/*
 *  Equivalent to somNew except that storage is not allocated.
 *  <obj> is taken as the address of the new object.
 */
   return SOM_ResolveD(this,M_RMDeviceCollection,SOMClass,somRenew)
	(this,obj);
}


/* method: somRenewNoInit */
SOMObject*   somRenewNoInit(void* obj)
{
/*
 *  Equivalent to somRenew except that somDefaultInit is not called.
 */
   return SOM_ResolveD(this,M_RMDeviceCollection,SOMClass,somRenewNoInit)
	(this,obj);
}


/* method: somRenewNoZero */
SOMObject*   somRenewNoZero(void* obj)
{
/*
 *  Equivalent to somRenew except that memory is not zeroed out.
 */
   return SOM_ResolveD(this,M_RMDeviceCollection,SOMClass,somRenewNoZero)
	(this,obj);
}


/* method: somRenewNoInitNoZero */
SOMObject*   somRenewNoInitNoZero(void* obj)
{
/*
 *  The purpose of this method is to load an object's method table.
 *  The SOM API requires that somRenewNoInitNoZero always be
 *  called when creating a new object whose metaclass is not SOMClass.
 *  This is because metaclasses must be guaranteed that they can use
 *  somRenewNoInitNoZero to track object creation if this is desired.
 */
   return SOM_ResolveD(this,M_RMDeviceCollection,SOMClass,somRenewNoInitNoZero)
	(this,obj);
}


/* nonstatic method: somAllocate */
somToken   somAllocate(long size)
{
/*
 *  Allocates memory to hold an object and returns a pointer to this memory.
 *  This is a nonstatic method, and cannot be overridden. The default
 *  implementation calls SOMMalloc, but a class designer can specify a
 *  different implementation using the somallocate modifier in IDL. The
 *  allocator takes the same parameters as this method.
 */
   return SOM_ResolveD(this,M_RMDeviceCollection,SOMClass,somAllocate)
	(this,size);
}


/* nonstatic method: somDeallocate */
void   somDeallocate(somToken memptr)
{
/*
 *  Zeros out the method table pointer stored in the word pointed to by
 *  memptr, and then deallocates the block of memory pointed to by memptr.
 *  This is a nonstatic method and cannot be overridden. The default
 *  deallocator called is SOMFree, but a class designer can specify a
 *  different deallocator using the somdeallocate modifier in IDL. The
 *  deallocator takes a char* (memptr) and a long (size) as arguments.
 */
   SOM_ResolveD(this,M_RMDeviceCollection,SOMClass,somDeallocate)
	(this,memptr);
}


/* method: somInitClass */
void   somInitClass(string className, 
		SOMClass* parentClass, 
		long dataSize, 
		long maxStaticMethods, 
		long majorVersion, 
		long minorVersion)
{
/*
 *  somInitClass is obsolete, and should no longer be used. The SOM 2.0
 *  kernel provides special handling for redispatch stubs in the case
 *  of SOM 1.0 classes, and use of this method is what tells the kernel
 *  that old-style redispatch stubs will be registered.
 */
   SOM_ResolveD(this,M_RMDeviceCollection,SOMClass,somInitClass)
	(this,className,parentClass,dataSize,maxStaticMethods,majorVersion,minorVersion);
}


/* method: somInitMIClass */
void   somInitMIClass(long inherit_vars, 
		string className, 
		SOMClass_SOMClassSequence* parentClasses, 
		long dataSize, 
		long dataAlignment, 
		long maxStaticMethods, 
		long majorVersion, 
		long minorVersion)
{
/*
 *  somInitMIClass implements the second phase of dynamic class creation:
 *  inheritance of interface and possibly implementation (instance
 *  variables) by suitable initialization of <self> (a class object).
 * 
 *  For somInitMIClass, the inherit_vars argument controls whether abstract
 *  or implementation inheritance is used. Inherit_vars is a 32 bit
 *  bit-vector. Implementation is inherited from parent i iff the bit
 *  1<<i is on, or i>=32.
 *  On a class-by-class basis, for each class ancestor, implementation
 *  inheritance always takes precidence over abstract inheritance. This is
 *  necessary to guarantee that procedures supporting parent method calls
 *  (available on non-abstract parents) are always supported by parent
 *  instance variables.
 * 
 *  <className> is a string containing the class name. A copy is made, so
 *  the string may be freed upon return to the caller if this is desired.
 * 
 *  <parentClasses> is a SOMClassSequence containing pointers to the
 *  parent classes. somInitMIClass makes a copy of this, so it may
 *  be freed upon return to the caller if this is desired.
 * 
 *  <dataSize> is the space needed for the instance variables
 *  introduced by this class.
 * 
 *  <dataAlignment> specifies the desired byte alignment for instance
 *  data introduced by this class. A value of 0 selects a system-wide default;
 *  any other argument is taken as the desired byte alignment multiple. Thus,
 *  for example, even if a byte multiple of 8 is needed for double precision
 *  values on a given system (so 8 is the default), a class whose instance data
 *  doesn't require this can indicate otherwise. If A is the next memory
 *  address available for holding instance data, the address that will be
 *  used is A + (A mod byte-alignment).
 * 
 *  <maxStaticMethods> is the maximum number of static methods that will be
 *  added to the initialized class using addStaticMethod.
 * 
 *  <majorVersion> indicates the major version number for this
 *  implementation of the class definition, and <minorVersion>
 *  indicates the minor version number.
 */
   SOM_ResolveD(this,M_RMDeviceCollection,SOMClass,somInitMIClass)
	(this,inherit_vars,className,parentClasses,dataSize,dataAlignment,maxStaticMethods,majorVersion,minorVersion);
}


/* method: somAddStaticMethod */
somMToken   somAddStaticMethod(somId methodId, 
		somId methodDescriptor, 
		somMethodPtr method, 
		somMethodPtr redispatchStub, 
		somMethodPtr applyStub)
{
/*
 *  Adds the indicated method, creating and returning a new method token.
 * 
 *  <methodDescriptor> is the somId for an identifier that can be used
 *  to access signature information about the method from an interface
 *  repository.
 * 
 *  <method> is the actual method procedure for this method
 * 
 *  <redispatchStub> is a procedure with the same calling sequence as
 *  <method> that invokes somDispatch for the method.
 * 
 *  <applyStub> is a procedure used to support somApply.
 */
   return SOM_ResolveD(this,M_RMDeviceCollection,SOMClass,somAddStaticMethod)
	(this,methodId,methodDescriptor,method,redispatchStub,applyStub);
}


/* method: somAddDynamicMethod */
void   somAddDynamicMethod(somId methodId, 
		somId methodDescriptor, 
		somMethodPtr method, 
		somMethodPtr applyStub)
{
/*
 *  Adds the indicated method to the class's name lookup list.
 *  If this happens to override a static method then this operation is
 *  equivalent to <somOverrideSMethod> and the <methodDescriptor> and
 *  <applyStub> arguments are ignored (the overridden method's values
 *  will be used).
 * 
 *  <methodDescriptor> is the somId for an identifier that can be used
 *  to access signature information about the method from an interface
 *  repository.
 * 
 *  <method> is the actual method procedure for this method
 * 
 *  <applyStub> is a procedure that takes a standard variable argument
 *  list data structure applies it to its target object by calling
 *  <method> with arguments derived from the data structure.  Its
 *  calling sequence is the same as the calling sequence of the
 *  dispatch methods defined in SOMObject.  This stub is used in the
 *  support of the dispatch methods used in some classes.  In classes
 *  where the dispatch functions do not need such a function this
 *  parameter may be null.
 */
   SOM_ResolveD(this,M_RMDeviceCollection,SOMClass,somAddDynamicMethod)
	(this,methodId,methodDescriptor,method,applyStub);
}


/* method: somOverrideSMethod */
void   somOverrideSMethod(somId methodId, 
		somMethodPtr method)
{
/*
 *  This method can be used instead of <somAddStaticMethod> or
 *  <somAddDynamicMethod> when it is known that the class' parent
 *  class already supports this method.  This call does not require the
 *  method descriptor and stub methods that the others do.
 */
   SOM_ResolveD(this,M_RMDeviceCollection,SOMClass,somOverrideSMethod)
	(this,methodId,method);
}


/* method: somClassReady */
void   somClassReady()
{
/*
 *  This method is invoked when all of the static initialization for
 *  the class has been finished.  The default implementation simply
 *  registers the newly constructed class with the SOMClassMgr.
 */
   SOM_ResolveD(this,M_RMDeviceCollection,SOMClass,somClassReady)
	(this);
}


/* method: somGetApplyStub */
somMethodPtr   somGetApplyStub(somId methodId)
{
/*
 *  Returns the apply stub associated with the specified method,
 *  if one exists; otherwise NULL is returned. This method is obsolete,
 *  and retained for binary compatability. In SOMr2, users never access
 *  apply stubs directly; The function somApply is used to invoke apply
 *  stubs. See somApply documentation for further information on apply
 *  stubs, and see somAddStaticMethod documentation for information
 *  on how apply stubs are registered by class implementations.
 */
   return SOM_ResolveD(this,M_RMDeviceCollection,SOMClass,somGetApplyStub)
	(this,methodId);
}


/* method: somGetClassData */
somClassDataStructure*   somGetClassData()
{
   return SOM_ResolveD(this,M_RMDeviceCollection,SOMClass,somGetClassData)
	(this);
}


/* method: somSetClassData */
void   somSetClassData(somClassDataStructure* cds)
{
/*
 *  The class' pointer to the static <className>ClassData structure.
 */
   SOM_ResolveD(this,M_RMDeviceCollection,SOMClass,somSetClassData)
	(this,cds);
}


/* method: somGetClassMtab */
somMethodTab*   somGetClassMtab()
{
/*
 *  A pointer to the method table used by instances of this class. This
 *  method was misnamed; it should have been called somGetInstanceMtab.
 */
   return SOM_ResolveD(this,M_RMDeviceCollection,SOMClass,somGetClassMtab)
	(this);
}


/* method: somGetInstanceOffset */
long   somGetInstanceOffset()
{
/*
 *  Returns the offset of instance data introduced by the receiver in
 *  an instance of the receiver. This method is obsolete and not useful in
 *  multiple-inheritance situations. The attribute somInstanceDataOffsets
 *  replaces this method.
 */
   return SOM_ResolveD(this,M_RMDeviceCollection,SOMClass,somGetInstanceOffset)
	(this);
}


/* method: somGetInstancePartSize */
long   somGetInstancePartSize()
{
/*
 *  The size in bytes of the instance data introduced by the receiving
 *  class.
 */
   return SOM_ResolveD(this,M_RMDeviceCollection,SOMClass,somGetInstancePartSize)
	(this);
}


/* method: somGetInstanceSize */
long   somGetInstanceSize()
{
/*
 *  The total size of an instance of the receiving class.
 */
   return SOM_ResolveD(this,M_RMDeviceCollection,SOMClass,somGetInstanceSize)
	(this);
}


/* method: somGetInstanceToken */
somDToken   somGetInstanceToken()
{
/*
 *  A data token that identifies the introduced portion of this class
 *  within itself or any derived class.  This token can be subsequently
 *  passed to the run-time somDataResolve function to locate the instance
 *  data introduced by this class in any object derived from this class.
 */
   return SOM_ResolveD(this,M_RMDeviceCollection,SOMClass,somGetInstanceToken)
	(this);
}


/* method: somGetMemberToken */
somDToken   somGetMemberToken(long memberOffset, 
		somDToken instanceToken)
{
/*
 *  Returns a data token that for the data member at offset
 *  "memberOffset" within the introduced portion of the class identified
 *  by instanceToken.  The instance token must have been obtained from a
 *  previous invocation of somGetInstanceToken.  The returned member
 *  token can be subsequently passed to the run-time somDataResolve
 *  function to locate the data member.
 */
   return SOM_ResolveD(this,M_RMDeviceCollection,SOMClass,somGetMemberToken)
	(this,memberOffset,instanceToken);
}


/* method: somGetMethodData */
boolean   somGetMethodData(somId methodId, 
		somMethodData* md)
{
/*
 *  If a method with id <methodId> is supported by the target class,
 *  the structure pointed to by <md> is loaded with method information
 *  and the value 1 is returned. In this case, if the method is not
 *  dynamic, md->method is loaded with the result of somClassResolve on
 *  the target class for the method. If the method is not supported,
 *  md->id is loaded with 0, and the value 0 is returned.
 */
   return SOM_ResolveD(this,M_RMDeviceCollection,SOMClass,somGetMethodData)
	(this,methodId,md);
}


/* method: somGetRdStub */
somMethodProc*   somGetRdStub(somId methodId)
{
/*
 *  Returns a redispatch stub for the indicated method, if possible.
 *  If not possible (because a valid redispatch stub has not been
 *  registered, and there is insufficient information to dynamically
 *  construct one), then a NULL is returned.
 */
   return SOM_ResolveD(this,M_RMDeviceCollection,SOMClass,somGetRdStub)
	(this,methodId);
}


/* method: somGetMethodDescriptor */
somId   somGetMethodDescriptor(somId methodId)
{
/*
 *  Returns the method descriptor for the indicated method.    If
 *  this object does not support the indicated method then NULL is
 *  returned.
 */
   return SOM_ResolveD(this,M_RMDeviceCollection,SOMClass,somGetMethodDescriptor)
	(this,methodId);
}


/* method: somGetMethodIndex */
long   somGetMethodIndex(somId id)
{
/*
 *  Returns the index for the specified method. (A number that may
 *  change if any methods are added or deleted to this class object or
 *  any of its ancestors).  This number is the basis for other calls to
 *  get info about the method. Indexes start at 0. A -1 is returned if
 *  the method cannot be found.
 */
   return SOM_ResolveD(this,M_RMDeviceCollection,SOMClass,somGetMethodIndex)
	(this,id);
}


/* method: somGetMethodToken */
somMToken   somGetMethodToken(somId methodId)
{
/*
 *  Returns the specified method's access token. This token can then
 *  be passed to method resolution routines, which use the token
 *  to select a method pointer from a method table.
 */
   return SOM_ResolveD(this,M_RMDeviceCollection,SOMClass,somGetMethodToken)
	(this,methodId);
}


/* method: somGetName */
string   somGetName()
{
/*
 *  This object's class name as a NULL terminated string.
 */
   return SOM_ResolveD(this,M_RMDeviceCollection,SOMClass,somGetName)
	(this);
}


/* method: somGetNthMethodData */
boolean   somGetNthMethodData(long n, 
		somMethodData* md)
{
/*
 *  loads *md with the method data associated with the the nth method,
 *  or NULL if there is no such method. Returns true is successful;
 *  false otherwise.
 */
   return SOM_ResolveD(this,M_RMDeviceCollection,SOMClass,somGetNthMethodData)
	(this,n,md);
}


/* method: somGetNthMethodInfo */
somId   somGetNthMethodInfo(long n, 
		somId* descriptor)
{
/*
 *  Returns the id of the <n>th method if one exists and NULL
 *  otherwise.
 * 
 *  The ordering of the methods is unpredictable, but will not change
 *  unless some change is made to the class or one of its ancestor classes.
 * 
 *  See CORBA documentation for info on method descriptors.
 */
   return SOM_ResolveD(this,M_RMDeviceCollection,SOMClass,somGetNthMethodInfo)
	(this,n,descriptor);
}


/* method: somGetNumMethods */
long   somGetNumMethods()
{
/*
 *  The number of methods currently supported by this class,
 *  including inherited methods (both static and dynamic).
 */
   return SOM_ResolveD(this,M_RMDeviceCollection,SOMClass,somGetNumMethods)
	(this);
}


/* method: somGetNumStaticMethods */
long   somGetNumStaticMethods()
{
/*
 *  The number of static methods that this class has.  Can
 *  be used by a child class when initializing its method table.
 */
   return SOM_ResolveD(this,M_RMDeviceCollection,SOMClass,somGetNumStaticMethods)
	(this);
}


/* method: somGetParent */
SOMClass*   somGetParent()
{
/*
 *  Returns the parent class of self (along its "left-hand" derivation
 *  path), if one exists and NULL otherwise.
 */
   return SOM_ResolveD(this,M_RMDeviceCollection,SOMClass,somGetParent)
	(this);
}


/* method: somGetParents */
SOMClass_SOMClassSequence   somGetParents()
{
/*
 *  The parent classes of self.
 */
   return SOM_ResolveD(this,M_RMDeviceCollection,SOMClass,somGetParents)
	(this);
}


/* method: somGetVersionNumbers */
void   somGetVersionNumbers(long* majorVersion, 
		long* minorVersion)
{
/*
 *  Returns the class' major and minor version numbers in the corresponding
 *  output parameters.
 */
   SOM_ResolveD(this,M_RMDeviceCollection,SOMClass,somGetVersionNumbers)
	(this,majorVersion,minorVersion);
}


/* method: somFindMethod */
boolean   somFindMethod(somId methodId, 
		somMethodPtr* m)
{
/*
 *  Finds the method procedure associated with <methodId> for this
 *  class and sets <m> to it.  1 (true) is returned when the
 *  method procedure is a static method and 0 (false) is returned
 *  when the method procedure is dynamic method.
 * 
 *  If the class does not support the specified method then
 *  <m> is set to NULL and the return value is meaningless.
 * 
 */
   return SOM_ResolveD(this,M_RMDeviceCollection,SOMClass,somFindMethod)
	(this,methodId,m);
}


/* method: somFindMethodOk */
boolean   somFindMethodOk(somId methodId, 
		somMethodPtr* m)
{
/*
 *  Just like <somFindMethod> except that if the method is not
 *  supported then an error is raised and execution is halted.
 */
   return SOM_ResolveD(this,M_RMDeviceCollection,SOMClass,somFindMethodOk)
	(this,methodId,m);
}


/* method: somFindSMethod */
somMethodPtr   somFindSMethod(somId methodId)
{
/*
 *  Finds the indicated method, which must be a static method supported
 *  by this class, and returns a pointer to its method procedure.
 *  If the method is not supported by the receiver (as a static method
 *  or at all) then a NULL pointer is returned.
 */
   return SOM_ResolveD(this,M_RMDeviceCollection,SOMClass,somFindSMethod)
	(this,methodId);
}


/* method: somFindSMethodOk */
somMethodPtr   somFindSMethodOk(somId methodId)
{
/*
 *  Uses <somFindSMethod>, and raises an error if the result is NULL.
 */
   return SOM_ResolveD(this,M_RMDeviceCollection,SOMClass,somFindSMethodOk)
	(this,methodId);
}


/* method: somLookupMethod */
somMethodPtr   somLookupMethod(somId methodId)
{
/*
 *  Like <somFindSMethodOK>, but without restriction to static methods.
 */
   return SOM_ResolveD(this,M_RMDeviceCollection,SOMClass,somLookupMethod)
	(this,methodId);
}


/* method: somCheckVersion */
boolean   somCheckVersion(long majorVersion, 
		long minorVersion)
{
/*
 *  Returns 1 (true) if the implementation of this class is
 *  compatible with the specified major and minor version number and
 *  false (0) otherwise.  An implementation is compatible with the
 *  specified version numbers if it has the same major version number
 *  and a minor version number that is equal to or greater than
 *  <minorVersion>.    The major, minor version number pair (0,0) is
 *  considered to match any version.  This method is usually called
 *  immediately after creating the class object to verify that a
 *  dynamically loaded class definition is compatible with a using
 *  application.
 */
   return SOM_ResolveD(this,M_RMDeviceCollection,SOMClass,somCheckVersion)
	(this,majorVersion,minorVersion);
}


/* method: somDescendedFrom */
boolean   somDescendedFrom(SOMClass* aClassObj)
{
/*
 *  Returns 1 (true) if <self> is a descendent class of <aClassObj> and
 *  0 (false) otherwise.  Note: a class object is considered to be
 *  descended itself for the purposes of this method.
 */
   return SOM_ResolveD(this,M_RMDeviceCollection,SOMClass,somDescendedFrom)
	(this,aClassObj);
}


/* method: somSupportsMethod */
boolean   somSupportsMethod(somId mId)
{
/*
 *  Returns 1 (true) if the indicated method is supported by this
 *  class and 0 (false) otherwise.
 */
   return SOM_ResolveD(this,M_RMDeviceCollection,SOMClass,somSupportsMethod)
	(this,mId);
}


/* method: somDefinedMethod */
somMethodPtr   somDefinedMethod(somMToken method)
{
/*
 *  if the receiving class either introduces or overrides the
 *  indicated method, then its somMethodPtr is returned, otherwise
 *  NULL is returned.
 */
   return SOM_ResolveD(this,M_RMDeviceCollection,SOMClass,somDefinedMethod)
	(this,method);
}


/* method: somOverrideMtab */
void   somOverrideMtab()
{
/*
 *  Overrides the method table pointers to point to the redispatch stubs.
 *  All the methods except somDispatch methods are overriden.
 */
   SOM_ResolveD(this,M_RMDeviceCollection,SOMClass,somOverrideMtab)
	(this);
}


/* 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_ResolveD(this,M_RMDeviceCollection,SOMObject,somDefaultInit)
	(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_ResolveD(this,M_RMDeviceCollection,SOMObject,somDestruct)
	(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_ResolveD(this,M_RMDeviceCollection,SOMObject,somDefaultCopyInit)
	(this,ctrl,fromObj);
}


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


/* initializer method: somDefaultConstCopyInit */
void   somDefaultConstCopyInit(som3InitCtrl* ctrl, 
		SOMObject* fromObj)
{
/*
 *  A default copy constructor that uses a const fromObj.
 */
   SOM_ResolveD(this,M_RMDeviceCollection,SOMObject,somDefaultConstCopyInit)
	(this,ctrl,fromObj);
}


/* initializer method: somDefaultVCopyInit */
void   somDefaultVCopyInit(som3InitCtrl* ctrl, 
		SOMObject* fromObj)
{
/*
 *  A default copy constructor that uses a volatile fromObj.
 */
   SOM_ResolveD(this,M_RMDeviceCollection,SOMObject,somDefaultVCopyInit)
	(this,ctrl,fromObj);
}


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


/* method: somDefaultConstAssign */
M_RMDeviceCollection*  somDefaultConstAssign(som3AssignCtrl* ctrl, 
		SOMObject* fromObj)
{
/*
 *  A default assignment operator that uses a const fromObj.
 */
   return SOM_ResolveD(this,M_RMDeviceCollection,SOMObject,somDefaultConstAssign)
	(this,ctrl,fromObj);
}


/* method: somDefaultVAssign */
M_RMDeviceCollection*  somDefaultVAssign(som3AssignCtrl* ctrl, 
		SOMObject* fromObj)
{
/*
 *  A default assignment operator that uses a volatile fromObj.
 */
   return SOM_ResolveD(this,M_RMDeviceCollection,SOMObject,somDefaultVAssign)
	(this,ctrl,fromObj);
}


/* method: somDefaultConstVAssign */
M_RMDeviceCollection*  somDefaultConstVAssign(som3AssignCtrl* ctrl, 
		SOMObject* fromObj)
{
/*
 *  A default assignment operator that uses a const volatile fromObj.
 */
   return SOM_ResolveD(this,M_RMDeviceCollection,SOMObject,somDefaultConstVAssign)
	(this,ctrl,fromObj);
}


/* method: somInit */
void   somInit()
{
/*
 *  Obsolete but still supported. Override somDefaultInit instead of somInit.
 */
   SOM_ResolveD(this,M_RMDeviceCollection,SOMObject,somInit)
	(this);
}


/* method: somFree */
void   somFree()
{
/*
 *  Use as directed by framework implementations.
 */
   SOM_ResolveD(this,M_RMDeviceCollection,SOMObject,somFree)
	(this);
}


/* method: somUninit */
void   somUninit()
{
/*
 *  Obsolete but still supported. Override somDestruct instead of somUninit.
 */
   SOM_ResolveD(this,M_RMDeviceCollection,SOMObject,somUninit)
	(this);
}


/* method: somGetClass */
SOMClass*   somGetClass()
{
/*
 *  Return the receiver's class.
 */
   return SOM_ResolveD(this,M_RMDeviceCollection,SOMObject,somGetClass)
	(this);
}


/* method: somGetClassName */
string   somGetClassName()
{
/*
 *  Return the name of the receiver's class.
 */
   return SOM_ResolveD(this,M_RMDeviceCollection,SOMObject,somGetClassName)
	(this);
}


/* method: somGetSize */
long   somGetSize()
{
/*
 *  Return the size of the receiver.
 */
   return SOM_ResolveD(this,M_RMDeviceCollection,SOMObject,somGetSize)
	(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_ResolveD(this,M_RMDeviceCollection,SOMObject,somIsA)
	(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_ResolveD(this,M_RMDeviceCollection,SOMObject,somIsInstanceOf)
	(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_ResolveD(this,M_RMDeviceCollection,SOMObject,somRespondsTo)
	(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.
 */
/* the va_list invocation form */
boolean   M_RMDeviceCollection_somDispatch(somToken* retValue, 
		somId methodId, 
		va_list ap)
{return SOM_ResolveD(this,M_RMDeviceCollection,SOMObject,somDispatch)
	(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.
 */
   va_list ap;
   va_start(ap, methodId);
   boolean __somResult = 
      SOM_ResolveD(this,M_RMDeviceCollection,SOMObject,somDispatch)
	(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   M_RMDeviceCollection_somClassDispatch(SOMClass* clsObj, 
		somToken* retValue, 
		somId methodId, 
		va_list ap)
{return SOM_ResolveD(this,M_RMDeviceCollection,SOMObject,somClassDispatch)
	(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_ResolveD(this,M_RMDeviceCollection,SOMObject,somClassDispatch)
	(this,clsObj,retValue,methodId,ap);
   va_end(ap);
   return __somResult;
}


/* method: somCastObj */
boolean   somCastObj(SOMClass* cls)
{
/*
 *  cast the receiving object to cls (which must be an ancestor of the
 *  objects true class. Returns true on success.
 */
   return SOM_ResolveD(this,M_RMDeviceCollection,SOMObject,somCastObj)
	(this,cls);
}


/* method: somResetObj */
boolean   somResetObj()
{
/*
 *  reset an object to its true class. Returns true always.
 */
   return SOM_ResolveD(this,M_RMDeviceCollection,SOMObject,somResetObj)
	(this);
}


/* va_list method: somDispatchV */

/*
 *  Obsolete. Use somDispatch instead.
 */
/* the va_list invocation form */
void   M_RMDeviceCollection_somDispatchV(somId methodId, 
		somId descriptor, 
		va_list ap)
{   SOM_ResolveD(this,M_RMDeviceCollection,SOMObject,somDispatchV)
	(this,methodId,descriptor,ap);
}

/* the varargs invocation form */
void   somDispatchV(somId methodId, 
		somId descriptor, 
		...)
{
/*
 *  Obsolete. Use somDispatch instead.
 */
   va_list ap;
   va_start(ap, descriptor);
   SOM_ResolveD(this,M_RMDeviceCollection,SOMObject,somDispatchV)
	(this,methodId,descriptor,ap);
   va_end(ap);
}


/* va_list method: somDispatchL */

/*
 *  Obsolete. Use somDispatch instead.
 */
/* the va_list invocation form */
long   M_RMDeviceCollection_somDispatchL(somId methodId, 
		somId descriptor, 
		va_list ap)
{return SOM_ResolveD(this,M_RMDeviceCollection,SOMObject,somDispatchL)
	(this,methodId,descriptor,ap);
}

/* the varargs invocation form */
long   somDispatchL(somId methodId, 
		somId descriptor, 
		...)
{
/*
 *  Obsolete. Use somDispatch instead.
 */
   va_list ap;
   va_start(ap, descriptor);
   long __somResult = 
      SOM_ResolveD(this,M_RMDeviceCollection,SOMObject,somDispatchL)
	(this,methodId,descriptor,ap);
   va_end(ap);
   return __somResult;
}


/* va_list method: somDispatchA */

/*
 *  Obsolete. Use somDispatch instead.
 */
/* the va_list invocation form */
void*   M_RMDeviceCollection_somDispatchA(somId methodId, 
		somId descriptor, 
		va_list ap)
{return SOM_ResolveD(this,M_RMDeviceCollection,SOMObject,somDispatchA)
	(this,methodId,descriptor,ap);
}

/* the varargs invocation form */
void*   somDispatchA(somId methodId, 
		somId descriptor, 
		...)
{
/*
 *  Obsolete. Use somDispatch instead.
 */
   va_list ap;
   va_start(ap, descriptor);
   void* __somResult = 
      SOM_ResolveD(this,M_RMDeviceCollection,SOMObject,somDispatchA)
	(this,methodId,descriptor,ap);
   va_end(ap);
   return __somResult;
}


/* va_list method: somDispatchD */

/*
 *  Obsolete. Use somDispatch instead.
 */
/* the va_list invocation form */
double   M_RMDeviceCollection_somDispatchD(somId methodId, 
		somId descriptor, 
		va_list ap)
{return SOM_ResolveD(this,M_RMDeviceCollection,SOMObject,somDispatchD)
	(this,methodId,descriptor,ap);
}

/* the varargs invocation form */
double   somDispatchD(somId methodId, 
		somId descriptor, 
		...)
{
/*
 *  Obsolete. Use somDispatch instead.
 */
   va_list ap;
   va_start(ap, descriptor);
   double __somResult = 
      SOM_ResolveD(this,M_RMDeviceCollection,SOMObject,somDispatchD)
	(this,methodId,descriptor,ap);
   va_end(ap);
   return __somResult;
}


/* method: somPrintSelf */
SOMObject*   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_ResolveD(this,M_RMDeviceCollection,SOMObject,somPrintSelf)
	(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_ResolveD(this,M_RMDeviceCollection,SOMObject,somDumpSelf)
	(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_ResolveD(this,M_RMDeviceCollection,SOMObject,somDumpSelfInt)
	(this,level);
}



};   /* M_RMDeviceCollection */



#endif       /* SOM_M_RMDeviceCollection_xh */