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

/*
 *    COMPONENT_NAME: somx
 * 
 *    ORIGINS: 27
 * 
 * 
 *    25H7912  (C)  COPYRIGHT International Business Machines Corp. 1996
 *    All Rights Reserved
 *    Licensed Materials - Property of IBM
 *    US Government Users Restricted Rights - Use, duplication or
 *    disclosure restricted by GSA ADP Schedule Contract with IBM Corp.
 * 
 *    @(#) 1.2 src/somples.nt/somk/cpp/derived/hello.idl, somples.somk, som3.0 12/13/96 10:56:46 [12/23/96 08:40:08]
 * 
 * 
 * DISCLAIMER OF WARRANTIES.
 * The following [enclosed] code is sample code created by IBM
 * Corporation. This sample code is not part of any standard or IBM
 * product and is provided to you solely for the purpose of assisting
 * you in the development of your applications.  The code is provided
 * "AS IS". IBM MAKES NO WARRANTIES, EXPRESS OR IMPLIED, INCLUDING BUT
 * NOT LIMITED TO THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
 * FOR A PARTICULAR PURPOSE, REGARDING THE FUNCTION OR PERFORMANCE OF
 * THIS CODE.  IBM shall not be liable for any damages arising out of
 * your use of the sample code, even if they have been advised of the
 * possibility of such damages.
 * 
 * DISTRIBUTION.
 * This sample code can be freely distributed, copied, altered, and
 * incorporated into other software, provided that it bears the above
 * Copyright notice and DISCLAIMER intact.
 */


#ifndef SOM_Hello_xh
#define SOM_Hello_xh


#define Hello_MajorVersion 0
#define Hello_MinorVersion 0
class Hello;

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

/* Metaclass */

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

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

/*
 * Start of bindings for IDL types
 */

class SOMClass;
class SOMObject;
class M_Hello;

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

/*
 * A function to create the Hello class object...
 */
SOMEXTERN 
#if defined(SOM_Module_hello_Source)
    SOMDLLEXPORT
#else
    SOMDLLIMPORT
#endif
 M_Hello * SOMLINK HelloNewClass(
		integer4 majorVersion,
		integer4 minorVersion);


/*
 * The API 2 ClassData Structures...
 */
class M_Hello;
SOMEXTERN struct HelloClassDataStructure {
	M_Hello *classObject;
	somMToken hello_;
	somMToken _get_hellomsg;
	somMToken _set_hellomsg;
} SOMDLINK 
#if defined(SOM_Module_hello_Source)
    SOMDLLEXPORT
#else
    SOMDLLIMPORT
#endif
 HelloClassData;
SOMEXTERN struct HelloCClassDataStructure {
	som3ClassDetailsPtr    parentMtab;
	somDToken              instanceDataToken;
} SOMDLINK 
#if defined(SOM_Module_hello_Source)
    SOMDLLEXPORT
#else
    SOMDLLIMPORT
#endif
 HelloCClassData;


/*
 * Class Object and Method Token Macros
 */
#define _SOMCLASS_Hello (HelloClassData.classObject)
#ifndef SOMGD_Hello
    #if (defined(_Hello) || defined(__Hello))
        #undef _Hello
        #undef __Hello
        #define SOMGD_Hello 1
    #else
        #define _Hello _SOMCLASS_Hello
    #endif /* _Hello */
#endif /* SOMGD_Hello */
#define Hello_classObj _SOMCLASS_Hello
#define _SOMMTOKEN_Hello(method) ((somMToken)HelloClassData.method)

/*
 * -- Typedefs for Hello Method Procedures
 */
SOMEXTERN {
typedef string   SOMLINK somTP_Hello_hello_(Hello *somSelf);
typedef somTP_Hello_hello_ *somTD_Hello_hello_;
typedef string   SOMLINK somTP_Hello__get_hellomsg(Hello *somSelf);
typedef somTP_Hello__get_hellomsg *somTD_Hello__get_hellomsg;
typedef void   SOMLINK somTP_Hello__set_hellomsg(Hello *somSelf, 
		string hellomsg);
typedef somTP_Hello__set_hellomsg *somTD_Hello__set_hellomsg;

/*
 * -- Typedefs for Reintroduced Wrapper Methods
 */
typedef void   SOMLINK somTP_Hello_somDefaultInit(Hello *somSelf, 
		som3InitCtrl* ctrl);
typedef somTP_Hello_somDefaultInit *somTD_Hello_somDefaultInit;
typedef void   SOMLINK somTP_Hello_somDestruct(Hello *somSelf, 
		octet doFree, 
		som3DestructCtrl* ctrl);
typedef somTP_Hello_somDestruct *somTD_Hello_somDestruct;
typedef void   SOMLINK somTP_Hello_somDefaultCopyInit(Hello *somSelf, 
		som3InitCtrl* ctrl, 
		SOMObject* fromObj);
typedef somTP_Hello_somDefaultCopyInit *somTD_Hello_somDefaultCopyInit;
typedef Hello*   SOMLINK somTP_Hello_somDefaultAssign(Hello *somSelf, 
		som3AssignCtrl* ctrl, 
		SOMObject* fromObj);
typedef somTP_Hello_somDefaultAssign *somTD_Hello_somDefaultAssign;
typedef void   SOMLINK somTP_Hello_somDefaultConstCopyInit(Hello *somSelf, 
		som3InitCtrl* ctrl, 
		SOMObject* fromObj);
typedef somTP_Hello_somDefaultConstCopyInit *somTD_Hello_somDefaultConstCopyInit;
typedef void   SOMLINK somTP_Hello_somDefaultVCopyInit(Hello *somSelf, 
		som3InitCtrl* ctrl, 
		SOMObject* fromObj);
typedef somTP_Hello_somDefaultVCopyInit *somTD_Hello_somDefaultVCopyInit;
typedef void   SOMLINK somTP_Hello_somDefaultConstVCopyInit(Hello *somSelf, 
		som3InitCtrl* ctrl, 
		SOMObject* fromObj);
typedef somTP_Hello_somDefaultConstVCopyInit *somTD_Hello_somDefaultConstVCopyInit;
typedef Hello*   SOMLINK somTP_Hello_somDefaultConstAssign(Hello *somSelf, 
		som3AssignCtrl* ctrl, 
		SOMObject* fromObj);
typedef somTP_Hello_somDefaultConstAssign *somTD_Hello_somDefaultConstAssign;
typedef Hello*   SOMLINK somTP_Hello_somDefaultVAssign(Hello *somSelf, 
		som3AssignCtrl* ctrl, 
		SOMObject* fromObj);
typedef somTP_Hello_somDefaultVAssign *somTD_Hello_somDefaultVAssign;
typedef Hello*   SOMLINK somTP_Hello_somDefaultConstVAssign(Hello *somSelf, 
		som3AssignCtrl* ctrl, 
		SOMObject* fromObj);
typedef somTP_Hello_somDefaultConstVAssign *somTD_Hello_somDefaultConstVAssign;
typedef void   SOMLINK somTP_Hello_somInit(Hello *somSelf);
typedef somTP_Hello_somInit *somTD_Hello_somInit;
typedef void   SOMLINK somTP_Hello_somUninit(Hello *somSelf);
typedef somTP_Hello_somUninit *somTD_Hello_somUninit;
typedef void   SOMLINK somTP_Hello_somFree(Hello *somSelf);
typedef somTP_Hello_somFree *somTD_Hello_somFree;
typedef M_Hello*   SOMLINK somTP_Hello_somGetClass(Hello *somSelf);
typedef somTP_Hello_somGetClass *somTD_Hello_somGetClass;
typedef string   SOMLINK somTP_Hello_somGetClassName(Hello *somSelf);
typedef somTP_Hello_somGetClassName *somTD_Hello_somGetClassName;
typedef long   SOMLINK somTP_Hello_somGetSize(Hello *somSelf);
typedef somTP_Hello_somGetSize *somTD_Hello_somGetSize;
typedef boolean   SOMLINK somTP_Hello_somIsA(Hello *somSelf, 
		SOMClass* aClassObj);
typedef somTP_Hello_somIsA *somTD_Hello_somIsA;
typedef boolean   SOMLINK somTP_Hello_somIsInstanceOf(Hello *somSelf, 
		SOMClass* aClassObj);
typedef somTP_Hello_somIsInstanceOf *somTD_Hello_somIsInstanceOf;
typedef boolean   SOMLINK somTP_Hello_somRespondsTo(Hello *somSelf, 
		somId mId);
typedef somTP_Hello_somRespondsTo *somTD_Hello_somRespondsTo;
typedef boolean   SOMLINK somTP_Hello_somDispatch(Hello *somSelf, 
		somToken* retValue, 
		somId methodId, 
		va_list ap);
typedef somTP_Hello_somDispatch *somTD_Hello_somDispatch;
typedef boolean   SOMLINK somTP_Hello_somClassDispatch(Hello *somSelf, 
		SOMClass* clsObj, 
		somToken* retValue, 
		somId methodId, 
		va_list ap);
typedef somTP_Hello_somClassDispatch *somTD_Hello_somClassDispatch;
typedef boolean   SOMLINK somTP_Hello_somCastObj(Hello *somSelf, 
		SOMClass* castedCls);
typedef somTP_Hello_somCastObj *somTD_Hello_somCastObj;
typedef boolean   SOMLINK somTP_Hello_somResetObj(Hello *somSelf);
typedef somTP_Hello_somResetObj *somTD_Hello_somResetObj;
typedef Hello*   SOMLINK somTP_Hello_somPrintSelf(Hello *somSelf);
typedef somTP_Hello_somPrintSelf *somTD_Hello_somPrintSelf;
typedef void   SOMLINK somTP_Hello_somDumpSelf(Hello *somSelf, 
		long level);
typedef somTP_Hello_somDumpSelf *somTD_Hello_somDumpSelf;
typedef void   SOMLINK somTP_Hello_somDumpSelfInt(Hello *somSelf, 
		long level);
typedef somTP_Hello_somDumpSelfInt *somTD_Hello_somDumpSelfInt;
}

#endif /* Hello_API */


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

// Hello::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 (!_Hello) HelloNewClass(Hello_MajorVersion,Hello_MinorVersion);
   return (void*)
   (((somTD_SOMClass_somNewNoInit)(SOMClassClassData.somNewNoInit))
         ((SOMClass *)((void*)_Hello)));
}

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

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

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

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


/* method: hello_ */
string   hello_()
{
   return 	(
	 SOM_TestCls(this,_SOMCLASS_Hello),
	 ((somTD_Hello_hello_)(HelloClassData.hello_))(((Hello *)((void *)this)))
	);
}


/* method: _get_hellomsg */
string   _get_hellomsg()
{
/*
 * Method from the IDL attribute statement:
 * "attribute string hellomsg"
 */
   return 	(
	 SOM_TestCls(this,_SOMCLASS_Hello),
	 ((somTD_Hello__get_hellomsg)(HelloClassData._get_hellomsg))(((Hello *)((void *)this)))
	);
}


/* method: _set_hellomsg */
void   _set_hellomsg(string hellomsg)
{
/*
 * Method from the IDL attribute statement:
 * "attribute string hellomsg"
 */
   	(
	 SOM_TestCls(this,_SOMCLASS_Hello),
	 ((somTD_Hello__set_hellomsg)(HelloClassData._set_hellomsg))(((Hello *)((void *)this)),hellomsg)
	);
}


/*
 * Reintroduce inherited methods
 */

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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


/* va_list method: somDispatch */

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

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


/* va_list method: somClassDispatch */

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

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


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


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


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


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


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



};   /* Hello */



#endif       /* SOM_Hello_xh */

#ifndef SOM_M_Hello_xh
#define SOM_M_Hello_xh


#define M_Hello_MajorVersion 0
#define M_Hello_MinorVersion 0
class M_Hello;

/* Parents */
#ifndef SOM_SOMClass_xh
#ifdef SOMLOCALINCLUDES
#include "somcls.xh"
#else
#include <somcls.xh>
#endif
#endif

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

/*
 * -- M_Hello is a metaclass for Hello. Make sure Hello is known.
 */
class Hello;


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

/*
 * Start of bindings for IDL types
 */


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

/*
 * A function to create the M_Hello class object...
 */
SOMEXTERN 
#if defined(SOM_Module_hello_Source)
    SOMDLLEXPORT
#else
    SOMDLLIMPORT
#endif
 SOMClass * SOMLINK M_HelloNewClass(
		integer4 majorVersion,
		integer4 minorVersion);


/*
 * The API 2 ClassData Structures...
 */
SOMEXTERN struct M_HelloClassDataStructure {
	SOMClass *classObject;
	somMToken HelloCreate;
} SOMDLINK 
#if defined(SOM_Module_hello_Source)
    SOMDLLEXPORT
#else
    SOMDLLIMPORT
#endif
 M_HelloClassData;
SOMEXTERN struct M_HelloCClassDataStructure {
	som3ClassDetailsPtr    parentMtab;
	somDToken              instanceDataToken;
} SOMDLINK 
#if defined(SOM_Module_hello_Source)
    SOMDLLEXPORT
#else
    SOMDLLIMPORT
#endif
 M_HelloCClassData;


/*
 * Class Object and Method Token Macros
 */
#define _SOMCLASS_M_Hello (M_HelloClassData.classObject)
#ifndef SOMGD_M_Hello
    #if (defined(_M_Hello) || defined(__M_Hello))
        #undef _M_Hello
        #undef __M_Hello
        #define SOMGD_M_Hello 1
    #else
        #define _M_Hello _SOMCLASS_M_Hello
    #endif /* _M_Hello */
#endif /* SOMGD_M_Hello */
#define M_Hello_classObj _SOMCLASS_M_Hello
#define _SOMMTOKEN_M_Hello(method) ((somMToken)M_HelloClassData.method)

/*
 * -- Typedefs for M_Hello Method Procedures
 */
SOMEXTERN {
typedef Hello*   SOMLINK somTP_M_Hello_HelloCreate(M_Hello *somSelf, 
		string msg);
typedef somTP_M_Hello_HelloCreate *somTD_M_Hello_HelloCreate;

/*
 * -- Typedefs for Reintroduced Wrapper Methods
 */
typedef Hello*   SOMLINK somTP_M_Hello_somNew(M_Hello *somSelf);
typedef somTP_M_Hello_somNew *somTD_M_Hello_somNew;
typedef SOMObject*   SOMLINK somTP_M_Hello_somNewNoInit(M_Hello *somSelf);
typedef somTP_M_Hello_somNewNoInit *somTD_M_Hello_somNewNoInit;
typedef SOMObject*   SOMLINK somTP_M_Hello_somRenew(M_Hello *somSelf, 
		void* obj);
typedef somTP_M_Hello_somRenew *somTD_M_Hello_somRenew;
typedef SOMObject*   SOMLINK somTP_M_Hello_somRenewNoInit(M_Hello *somSelf, 
		void* obj);
typedef somTP_M_Hello_somRenewNoInit *somTD_M_Hello_somRenewNoInit;
typedef SOMObject*   SOMLINK somTP_M_Hello_somRenewNoZero(M_Hello *somSelf, 
		void* obj);
typedef somTP_M_Hello_somRenewNoZero *somTD_M_Hello_somRenewNoZero;
typedef SOMObject*   SOMLINK somTP_M_Hello_somRenewNoInitNoZero(M_Hello *somSelf, 
		void* obj);
typedef somTP_M_Hello_somRenewNoInitNoZero *somTD_M_Hello_somRenewNoInitNoZero;
typedef somToken   SOMLINK somTP_M_Hello_somAllocate(M_Hello *somSelf, 
		long size);
typedef somTP_M_Hello_somAllocate *somTD_M_Hello_somAllocate;
typedef void   SOMLINK somTP_M_Hello_somDeallocate(M_Hello *somSelf, 
		somToken memptr);
typedef somTP_M_Hello_somDeallocate *somTD_M_Hello_somDeallocate;
typedef SOMClass*   SOMLINK somTP_M_Hello_somJoin(M_Hello *somSelf, 
		SOMClass* secondParent, 
		string nameOfNewClass);
typedef somTP_M_Hello_somJoin *somTD_M_Hello_somJoin;
typedef SOMClass*   SOMLINK somTP_M_Hello_somEndow(M_Hello *somSelf, 
		SOMClass* parent, 
		string nameOfNewClass);
typedef somTP_M_Hello_somEndow *somTD_M_Hello_somEndow;
typedef SOMClass*   SOMLINK somTP_M_Hello_somClassOfNewClassWithParents(string newClassName, 
		SOMClass_SOMClassSequence* parents, 
		SOMClass* explicitMeta);
typedef somTP_M_Hello_somClassOfNewClassWithParents *somTD_M_Hello_somClassOfNewClassWithParents;
typedef void   SOMLINK somTP_M_Hello_somInitMIClass(M_Hello *somSelf, 
		unsigned long inherit_vars, 
		string className, 
		SOMClass_SOMClassSequence* parentClasses, 
		long dataSize, 
		long dataAlignment, 
		long maxNDMethods, 
		long majorVersion, 
		long minorVersion);
typedef somTP_M_Hello_somInitMIClass *somTD_M_Hello_somInitMIClass;
typedef somMToken   SOMLINK somTP_M_Hello_somAddStaticMethod(M_Hello *somSelf, 
		somId methodId, 
		somId methodDescriptor, 
		somMethodPtr method, 
		somMethodPtr redispatchStub, 
		somMethodPtr applyStub);
typedef somTP_M_Hello_somAddStaticMethod *somTD_M_Hello_somAddStaticMethod;
typedef void   SOMLINK somTP_M_Hello_somOverrideSMethod(M_Hello *somSelf, 
		somId methodId, 
		somMethodPtr method);
typedef somTP_M_Hello_somOverrideSMethod *somTD_M_Hello_somOverrideSMethod;
typedef void   SOMLINK somTP_M_Hello_somClassReady(M_Hello *somSelf);
typedef somTP_M_Hello_somClassReady *somTD_M_Hello_somClassReady;
typedef void   SOMLINK somTP_M_Hello_somAddDynamicMethod(M_Hello *somSelf, 
		somId methodId, 
		somId methodDescriptor, 
		somMethodPtr methodImpl, 
		somMethodPtr applyStub);
typedef somTP_M_Hello_somAddDynamicMethod *somTD_M_Hello_somAddDynamicMethod;
typedef string   SOMLINK somTP_M_Hello_somGetName(M_Hello *somSelf);
typedef somTP_M_Hello_somGetName *somTD_M_Hello_somGetName;
typedef void   SOMLINK somTP_M_Hello_somGetVersionNumbers(M_Hello *somSelf, 
		long* majorVersion, 
		long* minorVersion);
typedef somTP_M_Hello_somGetVersionNumbers *somTD_M_Hello_somGetVersionNumbers;
typedef long   SOMLINK somTP_M_Hello_somGetNumMethods(M_Hello *somSelf);
typedef somTP_M_Hello_somGetNumMethods *somTD_M_Hello_somGetNumMethods;
typedef long   SOMLINK somTP_M_Hello_somGetNumStaticMethods(M_Hello *somSelf);
typedef somTP_M_Hello_somGetNumStaticMethods *somTD_M_Hello_somGetNumStaticMethods;
typedef SOMClass_SOMClassSequence   SOMLINK somTP_M_Hello_somGetParents(M_Hello *somSelf);
typedef somTP_M_Hello_somGetParents *somTD_M_Hello_somGetParents;
typedef long   SOMLINK somTP_M_Hello_somGetInstanceSize(M_Hello *somSelf);
typedef somTP_M_Hello_somGetInstanceSize *somTD_M_Hello_somGetInstanceSize;
typedef long   SOMLINK somTP_M_Hello_somGetInstancePartSize(M_Hello *somSelf);
typedef somTP_M_Hello_somGetInstancePartSize *somTD_M_Hello_somGetInstancePartSize;
typedef somDToken   SOMLINK somTP_M_Hello_somGetInstanceToken(M_Hello *somSelf);
typedef somTP_M_Hello_somGetInstanceToken *somTD_M_Hello_somGetInstanceToken;
typedef somDToken   SOMLINK somTP_M_Hello_somGetMemberToken(M_Hello *somSelf, 
		long memberOffset, 
		somDToken instanceToken);
typedef somTP_M_Hello_somGetMemberToken *somTD_M_Hello_somGetMemberToken;
typedef somMethodTab*   SOMLINK somTP_M_Hello_somGetClassMtab(M_Hello *somSelf);
typedef somTP_M_Hello_somGetClassMtab *somTD_M_Hello_somGetClassMtab;
typedef somClassDataStructurePtr   SOMLINK somTP_M_Hello_somGetClassData(M_Hello *somSelf);
typedef somTP_M_Hello_somGetClassData *somTD_M_Hello_somGetClassData;
typedef void   SOMLINK somTP_M_Hello_somSetClassData(M_Hello *somSelf, 
		somClassDataStructurePtr cds);
typedef somTP_M_Hello_somSetClassData *somTD_M_Hello_somSetClassData;
typedef long   SOMLINK somTP_M_Hello__get_somDataAlignment(M_Hello *somSelf);
typedef somTP_M_Hello__get_somDataAlignment *somTD_M_Hello__get_somDataAlignment;
typedef SOMClass_somOffsets   SOMLINK somTP_M_Hello__get_somInstanceDataOffsets(M_Hello *somSelf);
typedef somTP_M_Hello__get_somInstanceDataOffsets *somTD_M_Hello__get_somInstanceDataOffsets;
typedef SOMClass_SOMClassSequence   SOMLINK somTP_M_Hello__get_somDirectInitClasses(M_Hello *somSelf);
typedef somTP_M_Hello__get_somDirectInitClasses *somTD_M_Hello__get_somDirectInitClasses;
typedef somId   SOMLINK somTP_M_Hello_somGetMethodDescriptor(M_Hello *somSelf, 
		somId methodId);
typedef somTP_M_Hello_somGetMethodDescriptor *somTD_M_Hello_somGetMethodDescriptor;
typedef long   SOMLINK somTP_M_Hello_somGetMethodIndex(M_Hello *somSelf, 
		somId id);
typedef somTP_M_Hello_somGetMethodIndex *somTD_M_Hello_somGetMethodIndex;
typedef somMToken   SOMLINK somTP_M_Hello_somGetMethodToken(M_Hello *somSelf, 
		somId methodId);
typedef somTP_M_Hello_somGetMethodToken *somTD_M_Hello_somGetMethodToken;
typedef somId   SOMLINK somTP_M_Hello_somGetNthMethodInfo(M_Hello *somSelf, 
		long n, 
		somId* descriptor);
typedef somTP_M_Hello_somGetNthMethodInfo *somTD_M_Hello_somGetNthMethodInfo;
typedef somToken   SOMLINK somTP_M_Hello_somGetMarshalPlan(M_Hello *somSelf, 
		somId methodId);
typedef somTP_M_Hello_somGetMarshalPlan *somTD_M_Hello_somGetMarshalPlan;
typedef boolean   SOMLINK somTP_M_Hello_somGetMethodData(M_Hello *somSelf, 
		somId methodId, 
		somMethodData* md);
typedef somTP_M_Hello_somGetMethodData *somTD_M_Hello_somGetMethodData;
typedef boolean   SOMLINK somTP_M_Hello_somGetNthMethodData(M_Hello *somSelf, 
		long n, 
		somMethodData* md);
typedef somTP_M_Hello_somGetNthMethodData *somTD_M_Hello_somGetNthMethodData;
typedef boolean   SOMLINK somTP_M_Hello_somFindMethod(M_Hello *somSelf, 
		somId methodId, 
		somMethodPtr* m);
typedef somTP_M_Hello_somFindMethod *somTD_M_Hello_somFindMethod;
typedef boolean   SOMLINK somTP_M_Hello_somFindMethodOk(M_Hello *somSelf, 
		somId methodId, 
		somMethodPtr* m);
typedef somTP_M_Hello_somFindMethodOk *somTD_M_Hello_somFindMethodOk;
typedef somMethodPtr   SOMLINK somTP_M_Hello_somFindSMethod(M_Hello *somSelf, 
		somId methodId);
typedef somTP_M_Hello_somFindSMethod *somTD_M_Hello_somFindSMethod;
typedef somMethodPtr   SOMLINK somTP_M_Hello_somFindSMethodOk(M_Hello *somSelf, 
		somId methodId);
typedef somTP_M_Hello_somFindSMethodOk *somTD_M_Hello_somFindSMethodOk;
typedef somMethodPtr   SOMLINK somTP_M_Hello_somLookupMethod(M_Hello *somSelf, 
		somId methodId);
typedef somTP_M_Hello_somLookupMethod *somTD_M_Hello_somLookupMethod;
typedef somMethodPtr   SOMLINK somTP_M_Hello_somGetApplyStub(M_Hello *somSelf, 
		somId methodId);
typedef somTP_M_Hello_somGetApplyStub *somTD_M_Hello_somGetApplyStub;
typedef somMethodTabs   SOMLINK somTP_M_Hello_somGetPClsMtab(M_Hello *somSelf);
typedef somTP_M_Hello_somGetPClsMtab *somTD_M_Hello_somGetPClsMtab;
typedef boolean   SOMLINK somTP_M_Hello_somCheckVersion(M_Hello *somSelf, 
		long majorVersion, 
		long minorVersion);
typedef somTP_M_Hello_somCheckVersion *somTD_M_Hello_somCheckVersion;
typedef boolean   SOMLINK somTP_M_Hello_somDescendedFrom(M_Hello *somSelf, 
		SOMClass* aClassObj);
typedef somTP_M_Hello_somDescendedFrom *somTD_M_Hello_somDescendedFrom;
typedef boolean   SOMLINK somTP_M_Hello_somSupportsMethod(M_Hello *somSelf, 
		somId mId);
typedef somTP_M_Hello_somSupportsMethod *somTD_M_Hello_somSupportsMethod;
typedef somMethodPtr   SOMLINK somTP_M_Hello_somDefinedMethod(M_Hello *somSelf, 
		somMToken method);
typedef somTP_M_Hello_somDefinedMethod *somTD_M_Hello_somDefinedMethod;
typedef SOMClass*   SOMLINK somTP_M_Hello_somMethodImplOwner(M_Hello *somSelf, 
		somMethodData* md);
typedef somTP_M_Hello_somMethodImplOwner *somTD_M_Hello_somMethodImplOwner;
typedef somMethodProc*   SOMLINK somTP_M_Hello_somGetRdStub(M_Hello *somSelf, 
		somId methodId);
typedef somTP_M_Hello_somGetRdStub *somTD_M_Hello_somGetRdStub;
typedef void   SOMLINK somTP_M_Hello_somOverrideMtab(M_Hello *somSelf);
typedef somTP_M_Hello_somOverrideMtab *somTD_M_Hello_somOverrideMtab;
typedef void   SOMLINK somTP_M_Hello_somDefaultInit(M_Hello *somSelf, 
		som3InitCtrl* ctrl);
typedef somTP_M_Hello_somDefaultInit *somTD_M_Hello_somDefaultInit;
typedef void   SOMLINK somTP_M_Hello_somDestruct(M_Hello *somSelf, 
		octet doFree, 
		som3DestructCtrl* ctrl);
typedef somTP_M_Hello_somDestruct *somTD_M_Hello_somDestruct;
typedef void   SOMLINK somTP_M_Hello_somDefaultCopyInit(M_Hello *somSelf, 
		som3InitCtrl* ctrl, 
		SOMObject* fromObj);
typedef somTP_M_Hello_somDefaultCopyInit *somTD_M_Hello_somDefaultCopyInit;
typedef M_Hello*   SOMLINK somTP_M_Hello_somDefaultAssign(M_Hello *somSelf, 
		som3AssignCtrl* ctrl, 
		SOMObject* fromObj);
typedef somTP_M_Hello_somDefaultAssign *somTD_M_Hello_somDefaultAssign;
typedef void   SOMLINK somTP_M_Hello_somDefaultConstCopyInit(M_Hello *somSelf, 
		som3InitCtrl* ctrl, 
		SOMObject* fromObj);
typedef somTP_M_Hello_somDefaultConstCopyInit *somTD_M_Hello_somDefaultConstCopyInit;
typedef void   SOMLINK somTP_M_Hello_somDefaultVCopyInit(M_Hello *somSelf, 
		som3InitCtrl* ctrl, 
		SOMObject* fromObj);
typedef somTP_M_Hello_somDefaultVCopyInit *somTD_M_Hello_somDefaultVCopyInit;
typedef void   SOMLINK somTP_M_Hello_somDefaultConstVCopyInit(M_Hello *somSelf, 
		som3InitCtrl* ctrl, 
		SOMObject* fromObj);
typedef somTP_M_Hello_somDefaultConstVCopyInit *somTD_M_Hello_somDefaultConstVCopyInit;
typedef M_Hello*   SOMLINK somTP_M_Hello_somDefaultConstAssign(M_Hello *somSelf, 
		som3AssignCtrl* ctrl, 
		SOMObject* fromObj);
typedef somTP_M_Hello_somDefaultConstAssign *somTD_M_Hello_somDefaultConstAssign;
typedef M_Hello*   SOMLINK somTP_M_Hello_somDefaultVAssign(M_Hello *somSelf, 
		som3AssignCtrl* ctrl, 
		SOMObject* fromObj);
typedef somTP_M_Hello_somDefaultVAssign *somTD_M_Hello_somDefaultVAssign;
typedef M_Hello*   SOMLINK somTP_M_Hello_somDefaultConstVAssign(M_Hello *somSelf, 
		som3AssignCtrl* ctrl, 
		SOMObject* fromObj);
typedef somTP_M_Hello_somDefaultConstVAssign *somTD_M_Hello_somDefaultConstVAssign;
typedef void   SOMLINK somTP_M_Hello_somInit(M_Hello *somSelf);
typedef somTP_M_Hello_somInit *somTD_M_Hello_somInit;
typedef void   SOMLINK somTP_M_Hello_somUninit(M_Hello *somSelf);
typedef somTP_M_Hello_somUninit *somTD_M_Hello_somUninit;
typedef void   SOMLINK somTP_M_Hello_somFree(M_Hello *somSelf);
typedef somTP_M_Hello_somFree *somTD_M_Hello_somFree;
typedef SOMClass*   SOMLINK somTP_M_Hello_somGetClass(M_Hello *somSelf);
typedef somTP_M_Hello_somGetClass *somTD_M_Hello_somGetClass;
typedef string   SOMLINK somTP_M_Hello_somGetClassName(M_Hello *somSelf);
typedef somTP_M_Hello_somGetClassName *somTD_M_Hello_somGetClassName;
typedef long   SOMLINK somTP_M_Hello_somGetSize(M_Hello *somSelf);
typedef somTP_M_Hello_somGetSize *somTD_M_Hello_somGetSize;
typedef boolean   SOMLINK somTP_M_Hello_somIsA(M_Hello *somSelf, 
		SOMClass* aClassObj);
typedef somTP_M_Hello_somIsA *somTD_M_Hello_somIsA;
typedef boolean   SOMLINK somTP_M_Hello_somIsInstanceOf(M_Hello *somSelf, 
		SOMClass* aClassObj);
typedef somTP_M_Hello_somIsInstanceOf *somTD_M_Hello_somIsInstanceOf;
typedef boolean   SOMLINK somTP_M_Hello_somRespondsTo(M_Hello *somSelf, 
		somId mId);
typedef somTP_M_Hello_somRespondsTo *somTD_M_Hello_somRespondsTo;
typedef boolean   SOMLINK somTP_M_Hello_somDispatch(M_Hello *somSelf, 
		somToken* retValue, 
		somId methodId, 
		va_list ap);
typedef somTP_M_Hello_somDispatch *somTD_M_Hello_somDispatch;
typedef boolean   SOMLINK somTP_M_Hello_somClassDispatch(M_Hello *somSelf, 
		SOMClass* clsObj, 
		somToken* retValue, 
		somId methodId, 
		va_list ap);
typedef somTP_M_Hello_somClassDispatch *somTD_M_Hello_somClassDispatch;
typedef boolean   SOMLINK somTP_M_Hello_somCastObj(M_Hello *somSelf, 
		SOMClass* castedCls);
typedef somTP_M_Hello_somCastObj *somTD_M_Hello_somCastObj;
typedef boolean   SOMLINK somTP_M_Hello_somResetObj(M_Hello *somSelf);
typedef somTP_M_Hello_somResetObj *somTD_M_Hello_somResetObj;
typedef M_Hello*   SOMLINK somTP_M_Hello_somPrintSelf(M_Hello *somSelf);
typedef somTP_M_Hello_somPrintSelf *somTD_M_Hello_somPrintSelf;
typedef void   SOMLINK somTP_M_Hello_somDumpSelf(M_Hello *somSelf, 
		long level);
typedef somTP_M_Hello_somDumpSelf *somTD_M_Hello_somDumpSelf;
typedef void   SOMLINK somTP_M_Hello_somDumpSelfInt(M_Hello *somSelf, 
		long level);
typedef somTP_M_Hello_somDumpSelfInt *somTD_M_Hello_somDumpSelfInt;
}

#endif /* M_Hello_API */


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

// M_Hello::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_Hello) M_HelloNewClass(M_Hello_MajorVersion,M_Hello_MinorVersion);
   return (void*)
   (((somTD_SOMClass_somNewNoInit)(SOMClassClassData.somNewNoInit))
         ((SOMClass *)((void*)_M_Hello)));
}

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

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

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

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


/* method: HelloCreate */
Hello*   HelloCreate(string msg)
{
/*
 *  This method creates an instance of the Hello class and
 *  uses the value of "msg" to initialise it.
 */
   return 	(
	 SOM_TestCls(this,_SOMCLASS_M_Hello),
	 ((somTD_M_Hello_HelloCreate)(M_HelloClassData.HelloCreate))(((M_Hello *)((void *)this)),msg)
	);
}


/*
 * Reintroduce inherited methods
 */

/* method: somNew */
Hello*  somNew()
{
/*
 *  Uses somAllocate to allocate storage for a new
 *  instance of the receiving class, calls somRenewNoInitNoZero
 *  to load the new object's method table pointer, and then
 *  calls somDefaultInit to initialize the new object.
 *  Overrides are not expected. NULL is returned on failure.
 */
   return 	(
	 SOM_TestCls(this,_SOMCLASS_SOMClass),
	 ((somTD_M_Hello_somNew)(SOMClassClassData.somNew))(((M_Hello *)((void *)this)))
	);
}


/* method: somNewNoInit */
SOMObject*   somNewNoInit()
{
/*
 *  Equivalent to somNew except that somDefaultInit is not called.
 *  Overrides are not expected.
 */
   return 	(
	 SOM_TestCls(this,_SOMCLASS_SOMClass),
	 ((somTD_M_Hello_somNewNoInit)(SOMClassClassData.somNewNoInit))(((M_Hello *)((void *)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.
 *  Overrides are not expected.
 */
   return 	(
	 SOM_TestCls(this,_SOMCLASS_SOMClass),
	 ((somTD_M_Hello_somRenew)(SOMClassClassData.somRenew))(((M_Hello *)((void *)this)),obj)
	);
}


/* method: somRenewNoInit */
SOMObject*   somRenewNoInit(void* obj)
{
/*
 *  Equivalent to somRenew except that somDefaultInit is not called.
 *  Overrides are not expected.
 */
   return 	(
	 SOM_TestCls(this,_SOMCLASS_SOMClass),
	 ((somTD_M_Hello_somRenewNoInit)(SOMClassClassData.somRenewNoInit))(((M_Hello *)((void *)this)),obj)
	);
}


/* method: somRenewNoZero */
SOMObject*   somRenewNoZero(void* obj)
{
/*
 *  Equivalent to somRenew except that memory is not zeroed out.
 *  Overrides are not expected.
 */
   return 	(
	 SOM_TestCls(this,_SOMCLASS_SOMClass),
	 ((somTD_M_Hello_somRenewNoZero)(SOMClassClassData.somRenewNoZero))(((M_Hello *)((void *)this)),obj)
	);
}


/* method: somRenewNoInitNoZero */
SOMObject*   somRenewNoInitNoZero(void* obj)
{
/*
 *  This method loads an object's method table pointer, turning raw
 *  memory into an uninitialized SOM object. The other somNew and
 *  somRenew methods all call this method, so metaclasses can override
 *  this method to track object creation if this is desired. A relative
 *  parent call should be done from overrides.
 */
   return 	(
	 SOM_TestCls(this,_SOMCLASS_SOMClass),
	 ((somTD_M_Hello_somRenewNoInitNoZero)(SOMClassClassData.somRenewNoInitNoZero))(((M_Hello *)((void *)this)),obj)
	);
}


/* nonstatic method: somAllocate */
somToken   somAllocate(long size)
{
/*
 *  nonstatic
 *  Uses the memory allocation routine associated with the receiving
 *  class to allocate memory to hold an object of the indicated size.
 *  NULL is returned on failure. The default allocation routine uses
 *  SOMMalloc.
 */
   return 	(
	 SOM_TestCls(this,_SOMCLASS_SOMClass),
	 ((somTD_M_Hello_somAllocate)(SOMClassClassData.somAllocate))(((M_Hello *)((void *)this)),size)
	);
}


/* nonstatic method: somDeallocate */
void   somDeallocate(somToken memptr)
{
/*
 *  nonstatic
 *  Uses the memory deallocation routine associated with the receiving
 *  class to deallocate memory beginning at the address indicated by
 *  memptr. The first word of this memory (normally a method table
 *  pointer) is loaded with NULL. The deallocation routine receives
 *  a void* (memptr) and a size_t (size) as arguments.
 */
   	(
	 SOM_TestCls(this,_SOMCLASS_SOMClass),
	 ((somTD_M_Hello_somDeallocate)(SOMClassClassData.somDeallocate))(((M_Hello *)((void *)this)),memptr)
	);
}


/* method: somJoin */
SOMClass*   somJoin(SOMClass* secondParent, 
		string nameOfNewClass)
{
/*
 *  Creates the multiple inheritance join of the target class and the
 *  secondParent with the class name nameOfNewClass.
 */
   return 	(
	 SOM_TestCls(this,_SOMCLASS_SOMClass),
	 ((somTD_M_Hello_somJoin)(SOMClassClassData.somJoin))(((M_Hello *)((void *)this)),secondParent,nameOfNewClass)
	);
}


/* method: somEndow */
SOMClass*   somEndow(SOMClass* parent, 
		string nameOfNewClass)
{
/*
 *  Creates the a subclass of parent with the class name nameOfNewClass
 *  where the target class is an added metaclass constraint.
 *  NOTE: this means that the target class must be a metaclass.
 */
   return 	(
	 SOM_TestCls(this,_SOMCLASS_SOMClass),
	 ((somTD_M_Hello_somEndow)(SOMClassClassData.somEndow))(((M_Hello *)((void *)this)),parent,nameOfNewClass)
	);
}


/* noself procedure: somClassOfNewClassWithParents */
static SOMClass*   somClassOfNewClassWithParents(string newClassName, 
		SOMClass_SOMClassSequence* parents, 
		SOMClass* explicitMeta)
{
/*
 *  procedure
 *  returns a metaclass appropriate for use as the class of a new
 *  class with the given parents and explicit metaclass.
 */
   return  ((somTD_M_Hello_somClassOfNewClassWithParents)SOMClassClassData.somClassOfNewClassWithParents)(newClassName,parents,explicitMeta);
}


/* method: somInitMIClass */
void   somInitMIClass(unsigned long inherit_vars, 
		string className, 
		SOMClass_SOMClassSequence* parentClasses, 
		long dataSize, 
		long dataAlignment, 
		long maxNDMethods, 
		long majorVersion, 
		long minorVersion)
{
/*
 *  Perform inheritance into a class object from the specified parent
 *  classes, determine the layout of instances for the receiving class, and
 *  determine the layout of the instance method table for the receiving class.
 *  Overrides should perform relative parent calls.
 */
   	(
	 SOM_TestCls(this,_SOMCLASS_SOMClass),
	 ((somTD_M_Hello_somInitMIClass)(SOMClassClassData.somInitMIClass))(((M_Hello *)((void *)this)),inherit_vars,className,parentClasses,dataSize,dataAlignment,maxNDMethods,majorVersion,minorVersion)
	);
}


/* method: somAddStaticMethod */
somMToken   somAddStaticMethod(somId methodId, 
		somId methodDescriptor, 
		somMethodPtr method, 
		somMethodPtr redispatchStub, 
		somMethodPtr applyStub)
{
/*
 *  Introduce a new static method with the indicated methodId into
 *  the receiving class. Overrides should perform relative parent calls.
 */
   return 	(
	 SOM_TestCls(this,_SOMCLASS_SOMClass),
	 ((somTD_M_Hello_somAddStaticMethod)(SOMClassClassData.somAddStaticMethod))(((M_Hello *)((void *)this)),methodId,methodDescriptor,method,redispatchStub,applyStub)
	);
}


/* method: somOverrideSMethod */
void   somOverrideSMethod(somId methodId, 
		somMethodPtr method)
{
/*
 *  Replace the implementation for the indicated method in the instances
 *  of the receiving class. Overrides should perform relative parent calls.
 */
   	(
	 SOM_TestCls(this,_SOMCLASS_SOMClass),
	 ((somTD_M_Hello_somOverrideSMethod)(SOMClassClassData.somOverrideSMethod))(((M_Hello *)((void *)this)),methodId,method)
	);
}


/* method: somClassReady */
void   somClassReady()
{
/*
 *  This method is invoked when all of the static initialization for
 *  the class has been finished (i.e., its instance method table has
 *  been loaded) and allows final setup for the class to be done. When
 *  overriding this method, all setup should be done before doing a
 *  relative pcall, since SOMClass's implementation will register the
 *  class with the class manager.
 */
   	(
	 SOM_TestCls(this,_SOMCLASS_SOMClass),
	 ((somTD_M_Hello_somClassReady)(SOMClassClassData.somClassReady))(((M_Hello *)((void *)this)))
	);
}


/* method: somAddDynamicMethod */
void   somAddDynamicMethod(somId methodId, 
		somId methodDescriptor, 
		somMethodPtr methodImpl, 
		somMethodPtr applyStub)
{
/*
 *  If the receiving class supports a static method with the indicated
 *  methodId, then override the method with the indicated implementation.
 *  Otherwise, a dynamic method with the indicated methodId is added to
 *  the receiving class.
 */
   	(
	 SOM_TestCls(this,_SOMCLASS_SOMClass),
	 ((somTD_M_Hello_somAddDynamicMethod)(SOMClassClassData.somAddDynamicMethod))(((M_Hello *)((void *)this)),methodId,methodDescriptor,methodImpl,applyStub)
	);
}


/* method: somGetName */
string   somGetName()
{
/*
 *  This object's class name as a NULL terminated string.
 *  Overrides are not expected.
 */
   return 	(
	 SOM_TestCls(this,_SOMCLASS_SOMClass),
	 ((somTD_M_Hello_somGetName)(SOMClassClassData.somGetName))(((M_Hello *)((void *)this)))
	);
}


/* method: somGetVersionNumbers */
void   somGetVersionNumbers(long* majorVersion, 
		long* minorVersion)
{
/*
 *  Returns the class' major and minor version numbers in the corresponding
 *  output parameters.
 *  Overrides are not expected.
 */
   	(
	 SOM_TestCls(this,_SOMCLASS_SOMClass),
	 ((somTD_M_Hello_somGetVersionNumbers)(SOMClassClassData.somGetVersionNumbers))(((M_Hello *)((void *)this)),majorVersion,minorVersion)
	);
}


/* method: somGetNumMethods */
long   somGetNumMethods()
{
/*
 *  The number of methods currently supported by this class,
 *  including inherited methods (static, nonstatic, and dynamic).
 *  Overrides are not expected.
 */
   return 	(
	 SOM_TestCls(this,_SOMCLASS_SOMClass),
	 ((somTD_M_Hello_somGetNumMethods)(SOMClassClassData.somGetNumMethods))(((M_Hello *)((void *)this)))
	);
}


/* method: somGetNumStaticMethods */
long   somGetNumStaticMethods()
{
/*
 *  The number of nondynamic methods that this class has.  Can
 *  be used by a child class when initializing its method table.
 *  Overrides are not expected.
 */
   return 	(
	 SOM_TestCls(this,_SOMCLASS_SOMClass),
	 ((somTD_M_Hello_somGetNumStaticMethods)(SOMClassClassData.somGetNumStaticMethods))(((M_Hello *)((void *)this)))
	);
}


/* method: somGetParents */
SOMClass_SOMClassSequence   somGetParents()
{
/*
 *  Returns a sequence containing pointers to the receiver's parent classes.
 *  Caller is responsible for using SOMFree on the returned sequence buffer.
 *  Overrides are not expected.
 */
   return 	(
	 SOM_TestCls(this,_SOMCLASS_SOMClass),
	 ((somTD_M_Hello_somGetParents)(SOMClassClassData.somGetParents))(((M_Hello *)((void *)this)))
	);
}


/* method: somGetInstanceSize */
long   somGetInstanceSize()
{
/*
 *  The total size of an instance of the receiving class.
 *  Overrides are not expected.
 */
   return 	(
	 SOM_TestCls(this,_SOMCLASS_SOMClass),
	 ((somTD_M_Hello_somGetInstanceSize)(SOMClassClassData.somGetInstanceSize))(((M_Hello *)((void *)this)))
	);
}


/* method: somGetInstancePartSize */
long   somGetInstancePartSize()
{
/*
 *  The size in bytes of the instance data introduced by the receiving
 *  class.
 *  Overrides are not expected.
 */
   return 	(
	 SOM_TestCls(this,_SOMCLASS_SOMClass),
	 ((somTD_M_Hello_somGetInstancePartSize)(SOMClassClassData.somGetInstancePartSize))(((M_Hello *)((void *)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.
 *  Overrides are not expected.
 */
   return 	(
	 SOM_TestCls(this,_SOMCLASS_SOMClass),
	 ((somTD_M_Hello_somGetInstanceToken)(SOMClassClassData.somGetInstanceToken))(((M_Hello *)((void *)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.
 *  Overrides are not expected.
 */
   return 	(
	 SOM_TestCls(this,_SOMCLASS_SOMClass),
	 ((somTD_M_Hello_somGetMemberToken)(SOMClassClassData.somGetMemberToken))(((M_Hello *)((void *)this)),memberOffset,instanceToken)
	);
}


/* 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.
 *  Overrides are not expected.
 */
   return 	(
	 SOM_TestCls(this,_SOMCLASS_SOMClass),
	 ((somTD_M_Hello_somGetClassMtab)(SOMClassClassData.somGetClassMtab))(((M_Hello *)((void *)this)))
	);
}


/* method: somGetClassData */
somClassDataStructurePtr   somGetClassData()
{
   return 	(
	 SOM_TestCls(this,_SOMCLASS_SOMClass),
	 ((somTD_M_Hello_somGetClassData)(SOMClassClassData.somGetClassData))(((M_Hello *)((void *)this)))
	);
}


/* method: somSetClassData */
void   somSetClassData(somClassDataStructurePtr cds)
{
/*
 *  The pointer to the static <className>ClassData structure.
 *  Overrides are not expected.
 */
   	(
	 SOM_TestCls(this,_SOMCLASS_SOMClass),
	 ((somTD_M_Hello_somSetClassData)(SOMClassClassData.somSetClassData))(((M_Hello *)((void *)this)),cds)
	);
}


/* method: _get_somDataAlignment */
long   _get_somDataAlignment()
{
/*
 *  The alignment required for the instance data structure
 *  introduced by the receiving class.
 *  Overrides are not expected.
 */
   return 	(
	 SOM_TestCls(this,_SOMCLASS_SOMClass),
	 ((somTD_M_Hello__get_somDataAlignment)(SOMClassClassData._get_somDataAlignment))(((M_Hello *)((void *)this)))
	);
}


/* 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).
 *  The caller is responsible for freeing the returned sequence buffer.
 *  Overrides are not expected.
 */
   return 	(
	 SOM_TestCls(this,_SOMCLASS_SOMClass),
	 ((somTD_M_Hello__get_somInstanceDataOffsets)(SOMClassClassData._get_somInstanceDataOffsets))(((M_Hello *)((void *)this)))
	);
}


/* method: _get_somDirectInitClasses */
SOMClass_SOMClassSequence   _get_somDirectInitClasses()
{
/*
 *  The ancestors whose initializers the receiving class wants to
 *  directly invoke. Caller is responsible for freeing the returned
 *  sequence buffer.
 *  Overrides are not expected.
 */
   return 	(
	 SOM_TestCls(this,_SOMCLASS_SOMClass),
	 ((somTD_M_Hello__get_somDirectInitClasses)(SOMClassClassData._get_somDirectInitClasses))(((M_Hello *)((void *)this)))
	);
}


/* 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.
 *  Overrides are not expected.
 */
   return 	(
	 SOM_TestCls(this,_SOMCLASS_SOMClass),
	 ((somTD_M_Hello_somGetMethodDescriptor)(SOMClassClassData.somGetMethodDescriptor))(((M_Hello *)((void *)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.
 *  Overrides are not expected.
 */
   return 	(
	 SOM_TestCls(this,_SOMCLASS_SOMClass),
	 ((somTD_M_Hello_somGetMethodIndex)(SOMClassClassData.somGetMethodIndex))(((M_Hello *)((void *)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.
 *  Overrides are not expected.
 */
   return 	(
	 SOM_TestCls(this,_SOMCLASS_SOMClass),
	 ((somTD_M_Hello_somGetMethodToken)(SOMClassClassData.somGetMethodToken))(((M_Hello *)((void *)this)),methodId)
	);
}


/* 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.
 *  Overrides are not expected.
 */
   return 	(
	 SOM_TestCls(this,_SOMCLASS_SOMClass),
	 ((somTD_M_Hello_somGetNthMethodInfo)(SOMClassClassData.somGetNthMethodInfo))(((M_Hello *)((void *)this)),n,descriptor)
	);
}


/* method: somGetMarshalPlan */
somToken   somGetMarshalPlan(somId methodId)
{
/*
 *  uses namelookup from the target class to locate a method that has the
 *  indicated methodId, and returns that method's marshal plan if there
 *  is one. Otherwise, null is returned.
 *  Overrides are not expected.
 */
   return 	(
	 SOM_TestCls(this,_SOMCLASS_SOMClass),
	 ((somTD_M_Hello_somGetMarshalPlan)(SOMClassClassData.somGetMarshalPlan))(((M_Hello *)((void *)this)),methodId)
	);
}


/* method: somGetMethodData */
boolean   somGetMethodData(somId methodId, 
		somMethodData* md)
{
/*
 *  If the receiving class supports a method with the specified somId,
 *  then the method data pointed to by md is loaded with information
 *  for the method and 1 (TRUE) is returned. Otherwise md->id is set to
 *  NULL and 0 (FALSE) is returned. On success, the md->method field is
 *  loaded with a the address of a function that invokes the method
 *  implementation appropriate for instances of the receiving class.
 *  Successive calls for the same method are *not* guaranteed to load
 *  md->method with the same address. All somId-based method resolution
 *  routines use the md->method address computed by somGetMethodData
 *  as their resolution result.
 */
   return 	(
	 SOM_TestCls(this,_SOMCLASS_SOMClass),
	 ((somTD_M_Hello_somGetMethodData)(SOMClassClassData.somGetMethodData))(((M_Hello *)((void *)this)),methodId,md)
	);
}


/* method: somGetNthMethodData */
boolean   somGetNthMethodData(long n, 
		somMethodData* md)
{
/*
 *  This method is similar to somGetMethodData. The method
 *  whose data is returned is the method for which the receiving
 *  class would return n from somGetMethodIndex.
 */
   return 	(
	 SOM_TestCls(this,_SOMCLASS_SOMClass),
	 ((somTD_M_Hello_somGetNthMethodData)(SOMClassClassData.somGetNthMethodData))(((M_Hello *)((void *)this)),n,md)
	);
}


/* method: somFindMethod */
boolean   somFindMethod(somId methodId, 
		somMethodPtr* m)
{
/*
 *  If the receiving class supports a method with the specified
 *  methodId, m is set to the address of a function that
 *  will invoke the method implementation appropriate for instances
 *  of the receiving class and 1 (TRUE) is returned. Otherwise, m is
 *  set to NULL and 0 (FALSE) is returned. Successive calls on the
 *  same class with the same arguments are not guaranteed to return
 *  the same function address.
 *  Overrides are not expected.
 */
   return 	(
	 SOM_TestCls(this,_SOMCLASS_SOMClass),
	 ((somTD_M_Hello_somFindMethod)(SOMClassClassData.somFindMethod))(((M_Hello *)((void *)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.
 *  Overrides are not expected.
 */
   return 	(
	 SOM_TestCls(this,_SOMCLASS_SOMClass),
	 ((somTD_M_Hello_somFindMethodOk)(SOMClassClassData.somFindMethodOk))(((M_Hello *)((void *)this)),methodId,m)
	);
}


/* nonstatic 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 a function that will
 *  invoke the method implementation appropriate for instances of the
 *  receiving class. If the method is not supported by the receiver
 *  (as a static method or at all) then a NULL pointer is returned.
 *  Overrides are not expected.
 */
   return 	(
	 SOM_TestCls(this,_SOMCLASS_SOMClass),
	 ((somTD_M_Hello_somFindSMethod)(SOMClassClassData.somFindSMethod))(((M_Hello *)((void *)this)),methodId)
	);
}


/* method: somFindSMethodOk */
somMethodPtr   somFindSMethodOk(somId methodId)
{
/*
 *  Uses <somFindSMethod>, and raises an error if the result is NULL.
 *  Overrides are not expected.
 */
   return 	(
	 SOM_TestCls(this,_SOMCLASS_SOMClass),
	 ((somTD_M_Hello_somFindSMethodOk)(SOMClassClassData.somFindSMethodOk))(((M_Hello *)((void *)this)),methodId)
	);
}


/* method: somLookupMethod */
somMethodPtr   somLookupMethod(somId methodId)
{
/*
 *  Like <somFindSMethodOK>, but without restriction to static methods.
 *  Overrides are not expected.
 */
   return 	(
	 SOM_TestCls(this,_SOMCLASS_SOMClass),
	 ((somTD_M_Hello_somLookupMethod)(SOMClassClassData.somLookupMethod))(((M_Hello *)((void *)this)),methodId)
	);
}


/* 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.
 *  Overrides are not expected.
 */
   return 	(
	 SOM_TestCls(this,_SOMCLASS_SOMClass),
	 ((somTD_M_Hello_somGetApplyStub)(SOMClassClassData.somGetApplyStub))(((M_Hello *)((void *)this)),methodId)
	);
}


/* method: somGetPClsMtab */
somMethodTabs   somGetPClsMtab()
{
/*
 *  Returns a list of the method tables of this class's parent classes in the
 *  specific format required by somParentNumResolve (for making parent method
 *  calls. The first entry on the list is actually the method table of the
 *  receiving class. Because the CClassData structure contains this list, the
 *  method table for any class with a CClassData structure is statically
 *  available. This method now returns a list because older SI emitters load
 *  CClassData.parentMtab with the result of this call, and the new runtime
 *  requires a list of classes in that position.
 *  Overrides are not expected.
 */
   return 	(
	 SOM_TestCls(this,_SOMCLASS_SOMClass),
	 ((somTD_M_Hello_somGetPClsMtab)(SOMClassClassData.somGetPClsMtab))(((M_Hello *)((void *)this)))
	);
}


/* 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.
 *  Overrides are not expected.
 */
   return 	(
	 SOM_TestCls(this,_SOMCLASS_SOMClass),
	 ((somTD_M_Hello_somCheckVersion)(SOMClassClassData.somCheckVersion))(((M_Hello *)((void *)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.
 *  Overrides are not expected.
 */
   return 	(
	 SOM_TestCls(this,_SOMCLASS_SOMClass),
	 ((somTD_M_Hello_somDescendedFrom)(SOMClassClassData.somDescendedFrom))(((M_Hello *)((void *)this)),aClassObj)
	);
}


/* method: somSupportsMethod */
boolean   somSupportsMethod(somId mId)
{
/*
 *  Returns 1 (true) if the indicated method is supported by this
 *  class and 0 (false) otherwise.
 *  Overrides are not expected.
 */
   return 	(
	 SOM_TestCls(this,_SOMCLASS_SOMClass),
	 ((somTD_M_Hello_somSupportsMethod)(SOMClassClassData.somSupportsMethod))(((M_Hello *)((void *)this)),mId)
	);
}


/* method: somDefinedMethod */
somMethodPtr   somDefinedMethod(somMToken method)
{
/*
 *  If the receiving class explicitly defines an implementation for
 *  the indicated method, then the address of a function that will invoke
 *  this implementation is returned. Otherwise NULL is returned.
 *  Overrides are not expected.
 */
   return 	(
	 SOM_TestCls(this,_SOMCLASS_SOMClass),
	 ((somTD_M_Hello_somDefinedMethod)(SOMClassClassData.somDefinedMethod))(((M_Hello *)((void *)this)),method)
	);
}


/* nonstatic method: somMethodImplOwner */
SOMClass*   somMethodImplOwner(somMethodData* md)
{
/*
 *  Returns the owner of the implementation of the method indicated by md
 *  for instances of the receiving class, and loads md->method with a
 *  pointer to the method implementation. If the receiving class doesn't
 *  support the method, md->method is not changed, and null is returned.
 *  Implementations that are automatically installed by SOM (such as for
 *  SOMObject's initializers and for legacy support of somInit) are
 *  reported as being owned by SOMObject.
 *  Overrides are not expected.
 */
   return 	(
	 SOM_TestCls(this,_SOMCLASS_SOMClass),
	 ((somTD_M_Hello_somMethodImplOwner)(SOMClassClassData.somMethodImplOwner))(((M_Hello *)((void *)this)),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 pointer to a function that prints an
 *  informative message and terminates execution is returned.
 */
   return 	(
	 SOM_TestCls(this,_SOMCLASS_SOMClass),
	 ((somTD_M_Hello_somGetRdStub)(SOMClassClassData.somGetRdStub))(((M_Hello *)((void *)this)),methodId)
	);
}


/* method: somOverrideMtab */
void   somOverrideMtab()
{
/*
 *  Overrides the method table pointers to point to the redispatch stubs.
 *  All the methods except somDispatch methods are overriden.
 */
   	(
	 SOM_TestCls(this,_SOMCLASS_SOMClass),
	 ((somTD_M_Hello_somOverrideMtab)(SOMClassClassData.somOverrideMtab))(((M_Hello *)((void *)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_TestCls(this,_SOMCLASS_SOMObject),
	 ((somTD_M_Hello_somDefaultInit)(SOMObjectClassData.somDefaultInit))(((M_Hello *)((void *)this)),ctrl)
	);
}


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


/* va_list method: somDispatch */

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

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


/* va_list method: somClassDispatch */

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

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


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


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


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


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


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



};   /* M_Hello */



#endif       /* SOM_M_Hello_xh */
