home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / tolkit45.zip / os2tk45 / som / include / iogma.xh < prev    next >
Text File  |  1999-02-22  |  35KB  |  1,027 lines
  1.  
  2. /*
  3.  * This file was generated by the SOM Compiler.
  4.  * FileName: iogma.xh.
  5.  * Generated using:
  6.  *     SOM Precompiler somipc: 2.29.1.17
  7.  *     SOM Emitter emitxh: 2.47
  8.  */
  9.  
  10. /*
  11.  *    COMPONENT_NAME: somp
  12.  * 
  13.  *    ORIGINS: 27
  14.  * 
  15.  * 
  16.  *     25H7912  (C)  COPYRIGHT International Business Machines Corp. 1992,1994,1996
  17.  *    All Rights Reserved
  18.  *    Licensed Materials - Property of IBM
  19.  *    US Government Users Restricted Rights - Use, duplication or
  20.  *    disclosure restricted by GSA ADP Schedule Contract with IBM Corp.
  21.  * 
  22.  */
  23.  
  24.  
  25. #ifndef SOM_SOMPIOGroupMgrAbstract_xh
  26. #define SOM_SOMPIOGroupMgrAbstract_xh
  27.  
  28. class SOMPIOGroupMgrAbstract;
  29.  
  30. /*
  31.  *  This is the abstract class for an IO Group Manager object.  An IO Group
  32.  *  Manager is a class which is used by the Persistent Storage Manager
  33.  *  (see psm.sc) for storing/restoring persistent objects and groups of
  34.  *  persistent objects.
  35.  * 
  36.  *  An IO Group Manager object is the principle object which knows the
  37.  *  stored format of a group of objects stored on some media.  The IO
  38.  *  Group Manager does not know how an individual object is formatted.
  39.  *  The stored format of an individual object is known only by the
  40.  *  encoder/decoder for that object. The encoder/decoder for an object
  41.  *  is invoked by the IO Group Manager.
  42.  * 
  43.  *  There may be many IO Group Managers available in the system. The
  44.  *  IO Group Manager which is used to store a given persistent object is
  45.  *  determined by the persistent ID (see pid.sc) of that object. The
  46.  *  class name of the IO Group Manager is part of the persistent ID.
  47.  */
  48.  
  49. #define SOMPIOGroupMgrAbstract_MajorVersion 2
  50. #define SOMPIOGroupMgrAbstract_MinorVersion 1
  51.  
  52. /* C++ SOM defs */
  53. #include <somcls.xh>
  54. #include <somcm.xh>
  55.  
  56. /* C++ parent defs */
  57. #ifndef SOM_SOMObject_xh
  58. #include <somobj.xh>
  59. #endif
  60.  
  61. #ifndef SOMPIOGroupMgrAbstract_API
  62. #define SOMPIOGroupMgrAbstract_API
  63. /*
  64.  * -- The Class API
  65.  */
  66.  
  67. /*
  68.  * Start of bindings for IDL types
  69.  */
  70.  
  71. class SOMClass;
  72. class SOMObject;
  73. class SOMPMediaInterfaceAbstract;
  74. class SOMPIOGroup;
  75. class SOMPPersistentId;
  76. class SOMPPersistentObject;
  77.  
  78. /*
  79.  * End of bindings for IDL types.
  80.  */
  81.  
  82. /* A procedure to create the SOMPIOGroupMgrAbstract Class */
  83. SOMEXTERN SOMClass * SOMLINK SOMPIOGroupMgrAbstractNewClass(
  84.         integer4 majorVersion,
  85.         integer4 minorVersion);
  86.  
  87. /* The API to the SOMPIOGroupMgrAbstract class object, and the methods it introduces. */
  88. SOMEXTERN struct SOMPIOGroupMgrAbstractClassDataStructure {
  89.     SOMClass *classObject;
  90.     somMToken sompNewMediaInterface;
  91.     somMToken sompGetMediaInterface;
  92.     somMToken sompFreeMediaInterface;
  93.     somMToken sompInstantiateMediaInterface;
  94.     somMToken sompWriteGroup;
  95.     somMToken sompReadGroup;
  96.     somMToken sompReadObjectData;
  97.     somMToken sompGroupExists;
  98.     somMToken sompObjectInGroup;
  99.     somMToken sompMediaFormatOk;
  100.     somMToken sompDeleteObjectFromGroup;
  101. } SOMDLINK SOMPIOGroupMgrAbstractClassData;
  102. #define _SOMPIOGroupMgrAbstract SOMPIOGroupMgrAbstractClassData.classObject
  103.  
  104. /* The API to parentMtabs for SOMPIOGroupMgrAbstract, and the instance data it introduces. */
  105. SOMEXTERN struct SOMPIOGroupMgrAbstractCClassDataStructure {
  106.     somMethodTabs parentMtab;
  107.     somDToken              instanceDataToken;
  108. } SOMDLINK SOMPIOGroupMgrAbstractCClassData;
  109.  
  110. /*
  111.  * -- Typedefs for SOMPIOGroupMgrAbstract Method Procedures
  112.  */
  113. SOMEXTERN {
  114. typedef void   SOMLINK somTP_SOMPIOGroupMgrAbstract_sompNewMediaInterface(SOMPIOGroupMgrAbstract *somSelf, Environment *ev, 
  115.         string IOInfo);
  116. typedef somTP_SOMPIOGroupMgrAbstract_sompNewMediaInterface *somTD_SOMPIOGroupMgrAbstract_sompNewMediaInterface;
  117. typedef SOMPMediaInterfaceAbstract*   SOMLINK somTP_SOMPIOGroupMgrAbstract_sompGetMediaInterface(SOMPIOGroupMgrAbstract *somSelf, Environment *ev);
  118. typedef somTP_SOMPIOGroupMgrAbstract_sompGetMediaInterface *somTD_SOMPIOGroupMgrAbstract_sompGetMediaInterface;
  119. typedef void   SOMLINK somTP_SOMPIOGroupMgrAbstract_sompFreeMediaInterface(SOMPIOGroupMgrAbstract *somSelf, Environment *ev);
  120. typedef somTP_SOMPIOGroupMgrAbstract_sompFreeMediaInterface *somTD_SOMPIOGroupMgrAbstract_sompFreeMediaInterface;
  121. typedef SOMPMediaInterfaceAbstract*   SOMLINK somTP_SOMPIOGroupMgrAbstract_sompInstantiateMediaInterface(SOMPIOGroupMgrAbstract *somSelf, Environment *ev);
  122. typedef somTP_SOMPIOGroupMgrAbstract_sompInstantiateMediaInterface *somTD_SOMPIOGroupMgrAbstract_sompInstantiateMediaInterface;
  123. typedef boolean   SOMLINK somTP_SOMPIOGroupMgrAbstract_sompWriteGroup(SOMPIOGroupMgrAbstract *somSelf, Environment *ev, 
  124.         SOMPPersistentObject* thisPo);
  125. typedef somTP_SOMPIOGroupMgrAbstract_sompWriteGroup *somTD_SOMPIOGroupMgrAbstract_sompWriteGroup;
  126. typedef SOMPPersistentObject*   SOMLINK somTP_SOMPIOGroupMgrAbstract_sompReadGroup(SOMPIOGroupMgrAbstract *somSelf, Environment *ev, 
  127.         SOMPPersistentId* objectID);
  128. typedef somTP_SOMPIOGroupMgrAbstract_sompReadGroup *somTD_SOMPIOGroupMgrAbstract_sompReadGroup;
  129. typedef void   SOMLINK somTP_SOMPIOGroupMgrAbstract_sompReadObjectData(SOMPIOGroupMgrAbstract *somSelf, Environment *ev, 
  130.         SOMPPersistentObject* thisPo);
  131. typedef somTP_SOMPIOGroupMgrAbstract_sompReadObjectData *somTD_SOMPIOGroupMgrAbstract_sompReadObjectData;
  132. typedef boolean   SOMLINK somTP_SOMPIOGroupMgrAbstract_sompGroupExists(SOMPIOGroupMgrAbstract *somSelf, Environment *ev, 
  133.         string IOInfo);
  134. typedef somTP_SOMPIOGroupMgrAbstract_sompGroupExists *somTD_SOMPIOGroupMgrAbstract_sompGroupExists;
  135. typedef boolean   SOMLINK somTP_SOMPIOGroupMgrAbstract_sompObjectInGroup(SOMPIOGroupMgrAbstract *somSelf, Environment *ev, 
  136.         SOMPPersistentId* objectID);
  137. typedef somTP_SOMPIOGroupMgrAbstract_sompObjectInGroup *somTD_SOMPIOGroupMgrAbstract_sompObjectInGroup;
  138. typedef boolean   SOMLINK somTP_SOMPIOGroupMgrAbstract_sompMediaFormatOk(SOMPIOGroupMgrAbstract *somSelf, Environment *ev, 
  139.         string mediaFormatName);
  140. typedef somTP_SOMPIOGroupMgrAbstract_sompMediaFormatOk *somTD_SOMPIOGroupMgrAbstract_sompMediaFormatOk;
  141. typedef void   SOMLINK somTP_SOMPIOGroupMgrAbstract_sompDeleteObjectFromGroup(SOMPIOGroupMgrAbstract *somSelf, Environment *ev, 
  142.         SOMPPersistentId* objectID);
  143. typedef somTP_SOMPIOGroupMgrAbstract_sompDeleteObjectFromGroup *somTD_SOMPIOGroupMgrAbstract_sompDeleteObjectFromGroup;
  144.  
  145. /*
  146.  * -- Typedefs for Reintroduced Wrapper Methods
  147.  */
  148. typedef void   SOMLINK somTP_SOMPIOGroupMgrAbstract_somDefaultInit(SOMPIOGroupMgrAbstract *somSelf, 
  149.         som3InitCtrl* ctrl);
  150. typedef somTP_SOMPIOGroupMgrAbstract_somDefaultInit *somTD_SOMPIOGroupMgrAbstract_somDefaultInit;
  151. typedef void   SOMLINK somTP_SOMPIOGroupMgrAbstract_somDestruct(SOMPIOGroupMgrAbstract *somSelf, 
  152.         octet doFree, 
  153.         som3DestructCtrl* ctrl);
  154. typedef somTP_SOMPIOGroupMgrAbstract_somDestruct *somTD_SOMPIOGroupMgrAbstract_somDestruct;
  155. typedef void   SOMLINK somTP_SOMPIOGroupMgrAbstract_somDefaultCopyInit(SOMPIOGroupMgrAbstract *somSelf, 
  156.         som3InitCtrl* ctrl, 
  157.         SOMObject* fromObj);
  158. typedef somTP_SOMPIOGroupMgrAbstract_somDefaultCopyInit *somTD_SOMPIOGroupMgrAbstract_somDefaultCopyInit;
  159. typedef SOMPIOGroupMgrAbstract*   SOMLINK somTP_SOMPIOGroupMgrAbstract_somDefaultAssign(SOMPIOGroupMgrAbstract *somSelf, 
  160.         som3AssignCtrl* ctrl, 
  161.         SOMObject* fromObj);
  162. typedef somTP_SOMPIOGroupMgrAbstract_somDefaultAssign *somTD_SOMPIOGroupMgrAbstract_somDefaultAssign;
  163. typedef void   SOMLINK somTP_SOMPIOGroupMgrAbstract_somDefaultConstCopyInit(SOMPIOGroupMgrAbstract *somSelf, 
  164.         som3InitCtrl* ctrl, 
  165.         SOMObject* fromObj);
  166. typedef somTP_SOMPIOGroupMgrAbstract_somDefaultConstCopyInit *somTD_SOMPIOGroupMgrAbstract_somDefaultConstCopyInit;
  167. typedef void   SOMLINK somTP_SOMPIOGroupMgrAbstract_somDefaultVCopyInit(SOMPIOGroupMgrAbstract *somSelf, 
  168.         som3InitCtrl* ctrl, 
  169.         SOMObject* fromObj);
  170. typedef somTP_SOMPIOGroupMgrAbstract_somDefaultVCopyInit *somTD_SOMPIOGroupMgrAbstract_somDefaultVCopyInit;
  171. typedef void   SOMLINK somTP_SOMPIOGroupMgrAbstract_somDefaultConstVCopyInit(SOMPIOGroupMgrAbstract *somSelf, 
  172.         som3InitCtrl* ctrl, 
  173.         SOMObject* fromObj);
  174. typedef somTP_SOMPIOGroupMgrAbstract_somDefaultConstVCopyInit *somTD_SOMPIOGroupMgrAbstract_somDefaultConstVCopyInit;
  175. typedef SOMPIOGroupMgrAbstract*   SOMLINK somTP_SOMPIOGroupMgrAbstract_somDefaultConstAssign(SOMPIOGroupMgrAbstract *somSelf, 
  176.         som3AssignCtrl* ctrl, 
  177.         SOMObject* fromObj);
  178. typedef somTP_SOMPIOGroupMgrAbstract_somDefaultConstAssign *somTD_SOMPIOGroupMgrAbstract_somDefaultConstAssign;
  179. typedef SOMPIOGroupMgrAbstract*   SOMLINK somTP_SOMPIOGroupMgrAbstract_somDefaultVAssign(SOMPIOGroupMgrAbstract *somSelf, 
  180.         som3AssignCtrl* ctrl, 
  181.         SOMObject* fromObj);
  182. typedef somTP_SOMPIOGroupMgrAbstract_somDefaultVAssign *somTD_SOMPIOGroupMgrAbstract_somDefaultVAssign;
  183. typedef SOMPIOGroupMgrAbstract*   SOMLINK somTP_SOMPIOGroupMgrAbstract_somDefaultConstVAssign(SOMPIOGroupMgrAbstract *somSelf, 
  184.         som3AssignCtrl* ctrl, 
  185.         SOMObject* fromObj);
  186. typedef somTP_SOMPIOGroupMgrAbstract_somDefaultConstVAssign *somTD_SOMPIOGroupMgrAbstract_somDefaultConstVAssign;
  187. typedef void   SOMLINK somTP_SOMPIOGroupMgrAbstract_somInit(SOMPIOGroupMgrAbstract *somSelf);
  188. typedef somTP_SOMPIOGroupMgrAbstract_somInit *somTD_SOMPIOGroupMgrAbstract_somInit;
  189. typedef void   SOMLINK somTP_SOMPIOGroupMgrAbstract_somFree(SOMPIOGroupMgrAbstract *somSelf);
  190. typedef somTP_SOMPIOGroupMgrAbstract_somFree *somTD_SOMPIOGroupMgrAbstract_somFree;
  191. typedef void   SOMLINK somTP_SOMPIOGroupMgrAbstract_somUninit(SOMPIOGroupMgrAbstract *somSelf);
  192. typedef somTP_SOMPIOGroupMgrAbstract_somUninit *somTD_SOMPIOGroupMgrAbstract_somUninit;
  193. typedef SOMClass*   SOMLINK somTP_SOMPIOGroupMgrAbstract_somGetClass(SOMPIOGroupMgrAbstract *somSelf);
  194. typedef somTP_SOMPIOGroupMgrAbstract_somGetClass *somTD_SOMPIOGroupMgrAbstract_somGetClass;
  195. typedef string   SOMLINK somTP_SOMPIOGroupMgrAbstract_somGetClassName(SOMPIOGroupMgrAbstract *somSelf);
  196. typedef somTP_SOMPIOGroupMgrAbstract_somGetClassName *somTD_SOMPIOGroupMgrAbstract_somGetClassName;
  197. typedef long   SOMLINK somTP_SOMPIOGroupMgrAbstract_somGetSize(SOMPIOGroupMgrAbstract *somSelf);
  198. typedef somTP_SOMPIOGroupMgrAbstract_somGetSize *somTD_SOMPIOGroupMgrAbstract_somGetSize;
  199. typedef boolean   SOMLINK somTP_SOMPIOGroupMgrAbstract_somIsA(SOMPIOGroupMgrAbstract *somSelf, 
  200.         SOMClass* aClassObj);
  201. typedef somTP_SOMPIOGroupMgrAbstract_somIsA *somTD_SOMPIOGroupMgrAbstract_somIsA;
  202. typedef boolean   SOMLINK somTP_SOMPIOGroupMgrAbstract_somIsInstanceOf(SOMPIOGroupMgrAbstract *somSelf, 
  203.         SOMClass* aClassObj);
  204. typedef somTP_SOMPIOGroupMgrAbstract_somIsInstanceOf *somTD_SOMPIOGroupMgrAbstract_somIsInstanceOf;
  205. typedef boolean   SOMLINK somTP_SOMPIOGroupMgrAbstract_somRespondsTo(SOMPIOGroupMgrAbstract *somSelf, 
  206.         somId mId);
  207. typedef somTP_SOMPIOGroupMgrAbstract_somRespondsTo *somTD_SOMPIOGroupMgrAbstract_somRespondsTo;
  208. typedef boolean   SOMLINK somTP_SOMPIOGroupMgrAbstract_somDispatch(SOMPIOGroupMgrAbstract *somSelf, 
  209.         somToken* retValue, 
  210.         somId methodId, 
  211.         va_list ap);
  212. typedef somTP_SOMPIOGroupMgrAbstract_somDispatch *somTD_SOMPIOGroupMgrAbstract_somDispatch;
  213. typedef boolean   SOMLINK somTP_SOMPIOGroupMgrAbstract_somClassDispatch(SOMPIOGroupMgrAbstract *somSelf, 
  214.         SOMClass* clsObj, 
  215.         somToken* retValue, 
  216.         somId methodId, 
  217.         va_list ap);
  218. typedef somTP_SOMPIOGroupMgrAbstract_somClassDispatch *somTD_SOMPIOGroupMgrAbstract_somClassDispatch;
  219. typedef boolean   SOMLINK somTP_SOMPIOGroupMgrAbstract_somCastObj(SOMPIOGroupMgrAbstract *somSelf, 
  220.         SOMClass* cls);
  221. typedef somTP_SOMPIOGroupMgrAbstract_somCastObj *somTD_SOMPIOGroupMgrAbstract_somCastObj;
  222. typedef boolean   SOMLINK somTP_SOMPIOGroupMgrAbstract_somResetObj(SOMPIOGroupMgrAbstract *somSelf);
  223. typedef somTP_SOMPIOGroupMgrAbstract_somResetObj *somTD_SOMPIOGroupMgrAbstract_somResetObj;
  224. typedef void   SOMLINK somTP_SOMPIOGroupMgrAbstract_somDispatchV(SOMPIOGroupMgrAbstract *somSelf, 
  225.         somId methodId, 
  226.         somId descriptor, 
  227.         va_list ap);
  228. typedef somTP_SOMPIOGroupMgrAbstract_somDispatchV *somTD_SOMPIOGroupMgrAbstract_somDispatchV;
  229. typedef long   SOMLINK somTP_SOMPIOGroupMgrAbstract_somDispatchL(SOMPIOGroupMgrAbstract *somSelf, 
  230.         somId methodId, 
  231.         somId descriptor, 
  232.         va_list ap);
  233. typedef somTP_SOMPIOGroupMgrAbstract_somDispatchL *somTD_SOMPIOGroupMgrAbstract_somDispatchL;
  234. typedef void*   SOMLINK somTP_SOMPIOGroupMgrAbstract_somDispatchA(SOMPIOGroupMgrAbstract *somSelf, 
  235.         somId methodId, 
  236.         somId descriptor, 
  237.         va_list ap);
  238. typedef somTP_SOMPIOGroupMgrAbstract_somDispatchA *somTD_SOMPIOGroupMgrAbstract_somDispatchA;
  239. typedef double   SOMLINK somTP_SOMPIOGroupMgrAbstract_somDispatchD(SOMPIOGroupMgrAbstract *somSelf, 
  240.         somId methodId, 
  241.         somId descriptor, 
  242.         va_list ap);
  243. typedef somTP_SOMPIOGroupMgrAbstract_somDispatchD *somTD_SOMPIOGroupMgrAbstract_somDispatchD;
  244. typedef SOMObject*   SOMLINK somTP_SOMPIOGroupMgrAbstract_somPrintSelf(SOMPIOGroupMgrAbstract *somSelf);
  245. typedef somTP_SOMPIOGroupMgrAbstract_somPrintSelf *somTD_SOMPIOGroupMgrAbstract_somPrintSelf;
  246. typedef void   SOMLINK somTP_SOMPIOGroupMgrAbstract_somDumpSelf(SOMPIOGroupMgrAbstract *somSelf, 
  247.         long level);
  248. typedef somTP_SOMPIOGroupMgrAbstract_somDumpSelf *somTD_SOMPIOGroupMgrAbstract_somDumpSelf;
  249. typedef void   SOMLINK somTP_SOMPIOGroupMgrAbstract_somDumpSelfInt(SOMPIOGroupMgrAbstract *somSelf, 
  250.         long level);
  251. typedef somTP_SOMPIOGroupMgrAbstract_somDumpSelfInt *somTD_SOMPIOGroupMgrAbstract_somDumpSelfInt;
  252. }
  253.  
  254. #endif /* SOMPIOGroupMgrAbstract_API */
  255.  
  256.  
  257. /*
  258.  * -- This emitter treats Method Tokens as Thunks by default.
  259.  * -- Use the sc modifier "nothunks" to change this default
  260.  */
  261. #undef somresolve_
  262. #define somresolve_(obj,mToken) ((somMethodProc*)((void)obj, mToken))
  263.  
  264. /*
  265.  * -- The C++ Wrapper Class for SOMPIOGroupMgrAbstract
  266.  */
  267. class SOMPIOGroupMgrAbstract : public SOMObject
  268. {
  269. /*
  270.  *  This is the abstract class for an IO Group Manager object.  An IO Group
  271.  *  Manager is a class which is used by the Persistent Storage Manager
  272.  *  (see psm.sc) for storing/restoring persistent objects and groups of
  273.  *  persistent objects.
  274.  * 
  275.  *  An IO Group Manager object is the principle object which knows the
  276.  *  stored format of a group of objects stored on some media.  The IO
  277.  *  Group Manager does not know how an individual object is formatted.
  278.  *  The stored format of an individual object is known only by the
  279.  *  encoder/decoder for that object. The encoder/decoder for an object
  280.  *  is invoked by the IO Group Manager.
  281.  * 
  282.  *  There may be many IO Group Managers available in the system. The
  283.  *  IO Group Manager which is used to store a given persistent object is
  284.  *  determined by the persistent ID (see pid.sc) of that object. The
  285.  *  class name of the IO Group Manager is part of the persistent ID.
  286.  */
  287. public:
  288.  
  289. // SOMPIOGroupMgrAbstract::new creates the class object if necessary, and then uses somNewNoInit
  290. // to allocate memory and create the object. Initialization is in ctors.
  291. void *operator new(size_t)
  292. {
  293.    if (!_SOMPIOGroupMgrAbstract) SOMPIOGroupMgrAbstractNewClass(SOMPIOGroupMgrAbstract_MajorVersion,SOMPIOGroupMgrAbstract_MinorVersion);
  294.    return (void*)
  295.       SOM_Resolve(_SOMPIOGroupMgrAbstract,SOMClass,somNewNoInit)
  296.          ((SOMClass *)((void*)_SOMPIOGroupMgrAbstract));
  297. }
  298.  
  299. // SOMPIOGroupMgrAbstract::delete uses somDestruct.
  300. void operator delete(void * obj)
  301. {
  302.    if (obj && *(void**)obj) {
  303.       SOM_Resolve(obj,SOMObject,somFree)
  304.          ((SOMObject*)obj);
  305.    }
  306. }
  307.  
  308. SOMPIOGroupMgrAbstract& operator=(SOMPIOGroupMgrAbstract& fromObj)
  309. {
  310.    this->somDefaultAssign(0,(SOMObject*)((void*)&fromObj));
  311.    return *this;
  312. }
  313.  
  314. SOMPIOGroupMgrAbstract()
  315. {
  316.    if (*(void**)this != 
  317.        ((somParentMtabStructPtr)
  318.         (SOMPIOGroupMgrAbstractCClassData.parentMtab))->mtab)
  319.       return;
  320.    ((SOMObject*)((void*)this))->somDefaultInit(0);
  321. }
  322.  
  323. SOMPIOGroupMgrAbstract(SOMPIOGroupMgrAbstract* fromObj)
  324. {
  325.    if (*(void**)this != 
  326.        ((somParentMtabStructPtr)
  327.         (SOMPIOGroupMgrAbstractCClassData.parentMtab))->mtab)
  328.       return;
  329.    ((SOMObject*)((void*)this))->somDefaultCopyInit(0,((SOMObject*)((void*)fromObj)));
  330. }
  331.  
  332. #ifdef __IBMCPP__
  333. #pragma info(nocnv,nopar)
  334. #endif
  335. SOMPIOGroupMgrAbstract(const SOMPIOGroupMgrAbstract* fromObj)
  336. {
  337.    if (*(void**)this != 
  338.        ((somParentMtabStructPtr)
  339.         (SOMPIOGroupMgrAbstractCClassData.parentMtab))->mtab)
  340.       return;
  341.    ((SOMObject*)((void*)this))->somDefaultConstCopyInit(0,((SOMObject*)((void*)fromObj)));
  342. }
  343. #ifdef __IBMCPP__
  344. #pragma info(restore)
  345. #endif
  346.  
  347.  
  348. /* method: sompNewMediaInterface */
  349. void   sompNewMediaInterface(Environment *ev, 
  350.         string IOInfo)
  351. {
  352. /*
  353.  *  Gets a new Media Interface for this IO Group Mgr and prepares it
  354.  *  for I/O.  This method must be called prior to calling any of the
  355.  *  other methods of this class since other methods rely on the media
  356.  *  interface.
  357.  */
  358.    SOM_ResolveD(this,SOMPIOGroupMgrAbstract,SOMPIOGroupMgrAbstract,sompNewMediaInterface)
  359.     (this, ev,IOInfo);
  360. }
  361.  
  362.  
  363. /* method: sompGetMediaInterface */
  364. SOMPMediaInterfaceAbstract*   sompGetMediaInterface(Environment *ev)
  365. {
  366. /*
  367.  *  Returns this group's media interface. If sompNewMediaInterface
  368.  *  has not been called first, this method returns NULL.
  369.  *  This method also returns NULL after (the last) sompFreeMediaInterface.
  370.  */
  371.    return SOM_ResolveD(this,SOMPIOGroupMgrAbstract,SOMPIOGroupMgrAbstract,sompGetMediaInterface)
  372.     (this, ev);
  373. }
  374.  
  375.  
  376. /* method: sompFreeMediaInterface */
  377. void   sompFreeMediaInterface(Environment *ev)
  378. {
  379. /*
  380.  *  Frees this IOGroup Mgr's media interface.
  381.  */
  382.    SOM_ResolveD(this,SOMPIOGroupMgrAbstract,SOMPIOGroupMgrAbstract,sompFreeMediaInterface)
  383.     (this, ev);
  384. }
  385.  
  386.  
  387. /* method: sompInstantiateMediaInterface */
  388. SOMPMediaInterfaceAbstract*   sompInstantiateMediaInterface(Environment *ev)
  389. {
  390. /*
  391.  *  Override this if you want to change the MediaInterface
  392.  *  this IOGroupMananager uses to write out IO Groups.
  393.  */
  394.    return SOM_ResolveD(this,SOMPIOGroupMgrAbstract,SOMPIOGroupMgrAbstract,sompInstantiateMediaInterface)
  395.     (this, ev);
  396. }
  397.  
  398.  
  399. /* method: sompWriteGroup */
  400. boolean   sompWriteGroup(Environment *ev, 
  401.         SOMPPersistentObject* thisPo)
  402. {
  403. /*
  404.  *  Store the object and everything grouped with it or just store
  405.  *  the object given. It is the choice of the IO Group Mgr implementor.
  406.  * 
  407.  *  To store the object and all the others grouped with,
  408.  *  invoke _sompGetIOGroup(thisPo) to get the group and then
  409.  *  iterate across the group, storing each object. If a group is
  410.  *  stored this method must return TRUE.
  411.  *  Note:
  412.  *  Only objects in the IO Group which have been marked as "dirty"
  413.  *  should be stored. (See po.idl for methods to get the state of a
  414.  *  persistent object.)
  415.  * 
  416.  *  If the IO Group Mgr is written to store only the given object,
  417.  *  this method must return FALSE.
  418.  * 
  419.  *  OLD INTERFACE...
  420.  *  void sompWriteGroup(in SOMPIOGroup thisGroup) raises(SOMPError::sompException);
  421.  */
  422.    return SOM_ResolveD(this,SOMPIOGroupMgrAbstract,SOMPIOGroupMgrAbstract,sompWriteGroup)
  423.     (this, ev,thisPo);
  424. }
  425.  
  426.  
  427. /* method: sompReadGroup */
  428. SOMPPersistentObject*   sompReadGroup(Environment *ev, 
  429.         SOMPPersistentId* objectID)
  430. {
  431. /*
  432.  *  At the very least, this method will instantiate the persistent object which
  433.  *  is specified by the given objectID and return that object. This method
  434.  *  may be implemented to instantiate all the objects stored in the same group
  435.  *  as the specified object. It may restore objects and mark them as
  436.  *  SOMP_STATE_STABLE, however this is typically accomplished via the
  437.  *  sompReadObjectData.
  438.  *  The returned object is NULL if an error is encountered and
  439.  *  an exception is raised.
  440.  *  OLD INTERFACE...
  441.  *  SOMPIOGroup sompReadGroup(in string IOInfo) raises(SOMPError::sompException);
  442.  *  Restores the IO Group with the name given in <IOInfo>.
  443.  *  The instance data of the objects in the IO Group is not read.
  444.  *  The returned IO Group is NULL if an error is encountered and
  445.  *  an exception is raised.
  446.  */
  447.    return SOM_ResolveD(this,SOMPIOGroupMgrAbstract,SOMPIOGroupMgrAbstract,sompReadGroup)
  448.     (this, ev,objectID);
  449. }
  450.  
  451.  
  452. /* method: sompReadObjectData */
  453. void   sompReadObjectData(Environment *ev, 
  454.         SOMPPersistentObject* thisPo)
  455. {
  456. /*
  457.  *  Read the given persistent object's data from storage.
  458.  */
  459.    SOM_ResolveD(this,SOMPIOGroupMgrAbstract,SOMPIOGroupMgrAbstract,sompReadObjectData)
  460.     (this, ev,thisPo);
  461. }
  462.  
  463.  
  464. /* method: sompGroupExists */
  465. boolean   sompGroupExists(Environment *ev, 
  466.         string IOInfo)
  467. {
  468. /*
  469.  *  See if the IO Group with the name given in <IOInfo> exists in persistent
  470.  *  storage. Returns TRUE if group exists, FALSE otherwise.
  471.  */
  472.    return SOM_ResolveD(this,SOMPIOGroupMgrAbstract,SOMPIOGroupMgrAbstract,sompGroupExists)
  473.     (this, ev,IOInfo);
  474. }
  475.  
  476.  
  477. /* method: sompObjectInGroup */
  478. boolean   sompObjectInGroup(Environment *ev, 
  479.         SOMPPersistentId* objectID)
  480. {
  481. /*
  482.  *  See if the persisent object specified by <objectID> is in the group.
  483.  *  If so, return TRUE, otherwise FALSE.
  484.  */
  485.    return SOM_ResolveD(this,SOMPIOGroupMgrAbstract,SOMPIOGroupMgrAbstract,sompObjectInGroup)
  486.     (this, ev,objectID);
  487. }
  488.  
  489.  
  490. /* method: sompMediaFormatOk */
  491. boolean   sompMediaFormatOk(Environment *ev, 
  492.         string mediaFormatName)
  493. {
  494. /*
  495.  *  Check to see if the given mediaFormatName is supported by this
  496.  *  IO Group Manager. If it is, returns TRUE, otherwise returns FALSE.
  497.  */
  498.    return SOM_ResolveD(this,SOMPIOGroupMgrAbstract,SOMPIOGroupMgrAbstract,sompMediaFormatOk)
  499.     (this, ev,mediaFormatName);
  500. }
  501.  
  502.  
  503. /* method: sompDeleteObjectFromGroup */
  504. void   sompDeleteObjectFromGroup(Environment *ev, 
  505.         SOMPPersistentId* objectID)
  506. {
  507. /*
  508.  *  Delete the persisent object specified by <objectID>.
  509.  */
  510.    SOM_ResolveD(this,SOMPIOGroupMgrAbstract,SOMPIOGroupMgrAbstract,sompDeleteObjectFromGroup)
  511.     (this, ev,objectID);
  512. }
  513.  
  514.  
  515. /*
  516.  * Reintroduce inherited methods
  517.  */
  518.  
  519. /* initializer method: somDefaultInit */
  520. void   somDefaultInit(som3InitCtrl* ctrl)
  521. {
  522. /*
  523.  *  A default initializer for a SOM object. Passing a null ctrl
  524.  *  indicates to the receiver that its class is the class of the
  525.  *  object being initialized, whereby the initializer will determine
  526.  *  an appropriate control structure.
  527.  */
  528.    SOM_ResolveD(this,SOMPIOGroupMgrAbstract,SOMObject,somDefaultInit)
  529.     (this,ctrl);
  530. }
  531.  
  532.  
  533. /* method: somDestruct */
  534. void   somDestruct(octet doFree, 
  535.         som3DestructCtrl* ctrl)
  536. {
  537. /*
  538.  *  The default destructor for a SOM object. A nonzero <doFree>
  539.  *  indicates that the object storage should be freed by the
  540.  *  object's class (via somDeallocate) after uninitialization.
  541.  *  As with somDefaultInit, a null ctrl can be passed.
  542.  */
  543.    SOM_ResolveD(this,SOMPIOGroupMgrAbstract,SOMObject,somDestruct)
  544.     (this,doFree,ctrl);
  545. }
  546.  
  547.  
  548. /* initializer method: somDefaultCopyInit */
  549. void   somDefaultCopyInit(som3InitCtrl* ctrl, 
  550.         SOMObject* fromObj)
  551. {
  552. /*
  553.  *  A default copy constructor. Use this to make copies of objects for
  554.  *  calling methods with "by-value" argument semantics.
  555.  */
  556.    SOM_ResolveD(this,SOMPIOGroupMgrAbstract,SOMObject,somDefaultCopyInit)
  557.     (this,ctrl,fromObj);
  558. }
  559.  
  560.  
  561. /* method: somDefaultAssign */
  562. SOMPIOGroupMgrAbstract*  somDefaultAssign(som3AssignCtrl* ctrl, 
  563.         SOMObject* fromObj)
  564. {
  565. /*
  566.  *  A default assignment operator. Use this to "assign" the state of one
  567.  *  object to another.
  568.  */
  569.    return SOM_ResolveD(this,SOMPIOGroupMgrAbstract,SOMObject,somDefaultAssign)
  570.     (this,ctrl,fromObj);
  571. }
  572.  
  573.  
  574. /* initializer method: somDefaultConstCopyInit */
  575. void   somDefaultConstCopyInit(som3InitCtrl* ctrl, 
  576.         SOMObject* fromObj)
  577. {
  578. /*
  579.  *  A default copy constructor that uses a const fromObj.
  580.  */
  581.    SOM_ResolveD(this,SOMPIOGroupMgrAbstract,SOMObject,somDefaultConstCopyInit)
  582.     (this,ctrl,fromObj);
  583. }
  584.  
  585.  
  586. /* initializer method: somDefaultVCopyInit */
  587. void   somDefaultVCopyInit(som3InitCtrl* ctrl, 
  588.         SOMObject* fromObj)
  589. {
  590. /*
  591.  *  A default copy constructor that uses a volatile fromObj.
  592.  */
  593.    SOM_ResolveD(this,SOMPIOGroupMgrAbstract,SOMObject,somDefaultVCopyInit)
  594.     (this,ctrl,fromObj);
  595. }
  596.  
  597.  
  598. /* initializer method: somDefaultConstVCopyInit */
  599. void   somDefaultConstVCopyInit(som3InitCtrl* ctrl, 
  600.         SOMObject* fromObj)
  601. {
  602. /*
  603.  *  A default copy constructor that uses a const volatile fromObj.
  604.  */
  605.    SOM_ResolveD(this,SOMPIOGroupMgrAbstract,SOMObject,somDefaultConstVCopyInit)
  606.     (this,ctrl,fromObj);
  607. }
  608.  
  609.  
  610. /* method: somDefaultConstAssign */
  611. SOMPIOGroupMgrAbstract*  somDefaultConstAssign(som3AssignCtrl* ctrl, 
  612.         SOMObject* fromObj)
  613. {
  614. /*
  615.  *  A default assignment operator that uses a const fromObj.
  616.  */
  617.    return SOM_ResolveD(this,SOMPIOGroupMgrAbstract,SOMObject,somDefaultConstAssign)
  618.     (this,ctrl,fromObj);
  619. }
  620.  
  621.  
  622. /* method: somDefaultVAssign */
  623. SOMPIOGroupMgrAbstract*  somDefaultVAssign(som3AssignCtrl* ctrl, 
  624.         SOMObject* fromObj)
  625. {
  626. /*
  627.  *  A default assignment operator that uses a volatile fromObj.
  628.  */
  629.    return SOM_ResolveD(this,SOMPIOGroupMgrAbstract,SOMObject,somDefaultVAssign)
  630.     (this,ctrl,fromObj);
  631. }
  632.  
  633.  
  634. /* method: somDefaultConstVAssign */
  635. SOMPIOGroupMgrAbstract*  somDefaultConstVAssign(som3AssignCtrl* ctrl, 
  636.         SOMObject* fromObj)
  637. {
  638. /*
  639.  *  A default assignment operator that uses a const volatile fromObj.
  640.  */
  641.    return SOM_ResolveD(this,SOMPIOGroupMgrAbstract,SOMObject,somDefaultConstVAssign)
  642.     (this,ctrl,fromObj);
  643. }
  644.  
  645.  
  646. /* method: somInit */
  647. void   somInit()
  648. {
  649. /*
  650.  *  Obsolete but still supported. Override somDefaultInit instead of somInit.
  651.  */
  652.    SOM_ResolveD(this,SOMPIOGroupMgrAbstract,SOMObject,somInit)
  653.     (this);
  654. }
  655.  
  656.  
  657. /* method: somFree */
  658. void   somFree()
  659. {
  660. /*
  661.  *  Use as directed by framework implementations.
  662.  */
  663.    SOM_ResolveD(this,SOMPIOGroupMgrAbstract,SOMObject,somFree)
  664.     (this);
  665. }
  666.  
  667.  
  668. /* method: somUninit */
  669. void   somUninit()
  670. {
  671. /*
  672.  *  Obsolete but still supported. Override somDestruct instead of somUninit.
  673.  */
  674.    SOM_ResolveD(this,SOMPIOGroupMgrAbstract,SOMObject,somUninit)
  675.     (this);
  676. }
  677.  
  678.  
  679. /* method: somGetClass */
  680. SOMClass*   somGetClass()
  681. {
  682. /*
  683.  *  Return the receiver's class.
  684.  */
  685.    return SOM_ResolveD(this,SOMPIOGroupMgrAbstract,SOMObject,somGetClass)
  686.     (this);
  687. }
  688.  
  689.  
  690. /* method: somGetClassName */
  691. string   somGetClassName()
  692. {
  693. /*
  694.  *  Return the name of the receiver's class.
  695.  */
  696.    return SOM_ResolveD(this,SOMPIOGroupMgrAbstract,SOMObject,somGetClassName)
  697.     (this);
  698. }
  699.  
  700.  
  701. /* method: somGetSize */
  702. long   somGetSize()
  703. {
  704. /*
  705.  *  Return the size of the receiver.
  706.  */
  707.    return SOM_ResolveD(this,SOMPIOGroupMgrAbstract,SOMObject,somGetSize)
  708.     (this);
  709. }
  710.  
  711.  
  712. /* method: somIsA */
  713. boolean   somIsA(SOMClass* aClassObj)
  714. {
  715. /*
  716.  *  Returns 1 (true) if the receiver responds to methods
  717.  *  introduced by <aClassObj>, and 0 (false) otherwise.
  718.  */
  719.    return SOM_ResolveD(this,SOMPIOGroupMgrAbstract,SOMObject,somIsA)
  720.     (this,aClassObj);
  721. }
  722.  
  723.  
  724. /* method: somIsInstanceOf */
  725. boolean   somIsInstanceOf(SOMClass* aClassObj)
  726. {
  727. /*
  728.  *  Returns 1 (true) if the receiver is an instance of
  729.  *  <aClassObj> and 0 (false) otherwise.
  730.  */
  731.    return SOM_ResolveD(this,SOMPIOGroupMgrAbstract,SOMObject,somIsInstanceOf)
  732.     (this,aClassObj);
  733. }
  734.  
  735.  
  736. /* method: somRespondsTo */
  737. boolean   somRespondsTo(somId mId)
  738. {
  739. /*
  740.  *  Returns 1 (true) if the indicated method can be invoked
  741.  *  on the receiver and 0 (false) otherwise.
  742.  */
  743.    return SOM_ResolveD(this,SOMPIOGroupMgrAbstract,SOMObject,somRespondsTo)
  744.     (this,mId);
  745. }
  746.  
  747.  
  748. /* va_list method: somDispatch */
  749.  
  750. /*
  751.  *  This method provides a generic, class-specific dispatch mechanism.
  752.  *  It accepts as input <retValue> a pointer to the memory area to be
  753.  *  loaded with the result of dispatching the method indicated by
  754.  *  <methodId> using the arguments in <ap>. <ap> contains the object
  755.  *  on which the method is to be invoked as the first argument.
  756.  */
  757. /* the va_list invocation form */
  758. boolean   SOMPIOGroupMgrAbstract_somDispatch(somToken* retValue, 
  759.         somId methodId, 
  760.         va_list ap)
  761. {return SOM_ResolveD(this,SOMPIOGroupMgrAbstract,SOMObject,somDispatch)
  762.     (this,retValue,methodId,ap);
  763. }
  764.  
  765. /* the varargs invocation form */
  766. boolean   somDispatch(somToken* retValue, 
  767.         somId methodId, 
  768.         ...)
  769. {
  770. /*
  771.  *  This method provides a generic, class-specific dispatch mechanism.
  772.  *  It accepts as input <retValue> a pointer to the memory area to be
  773.  *  loaded with the result of dispatching the method indicated by
  774.  *  <methodId> using the arguments in <ap>. <ap> contains the object
  775.  *  on which the method is to be invoked as the first argument.
  776.  */
  777.    va_list ap;
  778.    va_start(ap, methodId);
  779.    boolean __somResult = 
  780.       SOM_ResolveD(this,SOMPIOGroupMgrAbstract,SOMObject,somDispatch)
  781.     (this,retValue,methodId,ap);
  782.    va_end(ap);
  783.    return __somResult;
  784. }
  785.  
  786.  
  787. /* va_list method: somClassDispatch */
  788.  
  789. /*
  790.  *  Like somDispatch, but method resolution for static methods is done
  791.  *  according to the clsObj instance method table.
  792.  */
  793. /* the va_list invocation form */
  794. boolean   SOMPIOGroupMgrAbstract_somClassDispatch(SOMClass* clsObj, 
  795.         somToken* retValue, 
  796.         somId methodId, 
  797.         va_list ap)
  798. {return SOM_ResolveD(this,SOMPIOGroupMgrAbstract,SOMObject,somClassDispatch)
  799.     (this,clsObj,retValue,methodId,ap);
  800. }
  801.  
  802. /* the varargs invocation form */
  803. boolean   somClassDispatch(SOMClass* clsObj, 
  804.         somToken* retValue, 
  805.         somId methodId, 
  806.         ...)
  807. {
  808. /*
  809.  *  Like somDispatch, but method resolution for static methods is done
  810.  *  according to the clsObj instance method table.
  811.  */
  812.    va_list ap;
  813.    va_start(ap, methodId);
  814.    boolean __somResult = 
  815.       SOM_ResolveD(this,SOMPIOGroupMgrAbstract,SOMObject,somClassDispatch)
  816.     (this,clsObj,retValue,methodId,ap);
  817.    va_end(ap);
  818.    return __somResult;
  819. }
  820.  
  821.  
  822. /* method: somCastObj */
  823. boolean   somCastObj(SOMClass* cls)
  824. {
  825. /*
  826.  *  cast the receiving object to cls (which must be an ancestor of the
  827.  *  objects true class. Returns true on success.
  828.  */
  829.    return SOM_ResolveD(this,SOMPIOGroupMgrAbstract,SOMObject,somCastObj)
  830.     (this,cls);
  831. }
  832.  
  833.  
  834. /* method: somResetObj */
  835. boolean   somResetObj()
  836. {
  837. /*
  838.  *  reset an object to its true class. Returns true always.
  839.  */
  840.    return SOM_ResolveD(this,SOMPIOGroupMgrAbstract,SOMObject,somResetObj)
  841.     (this);
  842. }
  843.  
  844.  
  845. /* va_list method: somDispatchV */
  846.  
  847. /*
  848.  *  Obsolete. Use somDispatch instead.
  849.  */
  850. /* the va_list invocation form */
  851. void   SOMPIOGroupMgrAbstract_somDispatchV(somId methodId, 
  852.         somId descriptor, 
  853.         va_list ap)
  854. {   SOM_ResolveD(this,SOMPIOGroupMgrAbstract,SOMObject,somDispatchV)
  855.     (this,methodId,descriptor,ap);
  856. }
  857.  
  858. /* the varargs invocation form */
  859. void   somDispatchV(somId methodId, 
  860.         somId descriptor, 
  861.         ...)
  862. {
  863. /*
  864.  *  Obsolete. Use somDispatch instead.
  865.  */
  866.    va_list ap;
  867.    va_start(ap, descriptor);
  868.    SOM_ResolveD(this,SOMPIOGroupMgrAbstract,SOMObject,somDispatchV)
  869.     (this,methodId,descriptor,ap);
  870.    va_end(ap);
  871. }
  872.  
  873.  
  874. /* va_list method: somDispatchL */
  875.  
  876. /*
  877.  *  Obsolete. Use somDispatch instead.
  878.  */
  879. /* the va_list invocation form */
  880. long   SOMPIOGroupMgrAbstract_somDispatchL(somId methodId, 
  881.         somId descriptor, 
  882.         va_list ap)
  883. {return SOM_ResolveD(this,SOMPIOGroupMgrAbstract,SOMObject,somDispatchL)
  884.     (this,methodId,descriptor,ap);
  885. }
  886.  
  887. /* the varargs invocation form */
  888. long   somDispatchL(somId methodId, 
  889.         somId descriptor, 
  890.         ...)
  891. {
  892. /*
  893.  *  Obsolete. Use somDispatch instead.
  894.  */
  895.    va_list ap;
  896.    va_start(ap, descriptor);
  897.    long __somResult = 
  898.       SOM_ResolveD(this,SOMPIOGroupMgrAbstract,SOMObject,somDispatchL)
  899.     (this,methodId,descriptor,ap);
  900.    va_end(ap);
  901.    return __somResult;
  902. }
  903.  
  904.  
  905. /* va_list method: somDispatchA */
  906.  
  907. /*
  908.  *  Obsolete. Use somDispatch instead.
  909.  */
  910. /* the va_list invocation form */
  911. void*   SOMPIOGroupMgrAbstract_somDispatchA(somId methodId, 
  912.         somId descriptor, 
  913.         va_list ap)
  914. {return SOM_ResolveD(this,SOMPIOGroupMgrAbstract,SOMObject,somDispatchA)
  915.     (this,methodId,descriptor,ap);
  916. }
  917.  
  918. /* the varargs invocation form */
  919. void*   somDispatchA(somId methodId, 
  920.         somId descriptor, 
  921.         ...)
  922. {
  923. /*
  924.  *  Obsolete. Use somDispatch instead.
  925.  */
  926.    va_list ap;
  927.    va_start(ap, descriptor);
  928.    void* __somResult = 
  929.       SOM_ResolveD(this,SOMPIOGroupMgrAbstract,SOMObject,somDispatchA)
  930.     (this,methodId,descriptor,ap);
  931.    va_end(ap);
  932.    return __somResult;
  933. }
  934.  
  935.  
  936. /* va_list method: somDispatchD */
  937.  
  938. /*
  939.  *  Obsolete. Use somDispatch instead.
  940.  */
  941. /* the va_list invocation form */
  942. double   SOMPIOGroupMgrAbstract_somDispatchD(somId methodId, 
  943.         somId descriptor, 
  944.         va_list ap)
  945. {return SOM_ResolveD(this,SOMPIOGroupMgrAbstract,SOMObject,somDispatchD)
  946.     (this,methodId,descriptor,ap);
  947. }
  948.  
  949. /* the varargs invocation form */
  950. double   somDispatchD(somId methodId, 
  951.         somId descriptor, 
  952.         ...)
  953. {
  954. /*
  955.  *  Obsolete. Use somDispatch instead.
  956.  */
  957.    va_list ap;
  958.    va_start(ap, descriptor);
  959.    double __somResult = 
  960.       SOM_ResolveD(this,SOMPIOGroupMgrAbstract,SOMObject,somDispatchD)
  961.     (this,methodId,descriptor,ap);
  962.    va_end(ap);
  963.    return __somResult;
  964. }
  965.  
  966.  
  967. /* method: somPrintSelf */
  968. SOMObject*   somPrintSelf()
  969. {
  970. /*
  971.  *  Uses <SOMOutCharRoutine> to write a brief string with identifying
  972.  *  information about this object.  The default implementation just gives
  973.  *  the object's class name and its address in memory.
  974.  *  <self> is returned.
  975.  */
  976.    return SOM_ResolveD(this,SOMPIOGroupMgrAbstract,SOMObject,somPrintSelf)
  977.     (this);
  978. }
  979.  
  980.  
  981. /* method: somDumpSelf */
  982. void   somDumpSelf(long level)
  983. {
  984. /*
  985.  *  Uses <SOMOutCharRoutine> to write a detailed description of this object
  986.  *  and its current state.
  987.  * 
  988.  *  <level> indicates the nesting level for describing compound objects
  989.  *  it must be greater than or equal to zero.  All lines in the
  990.  *  description will be preceeded by <2*level> spaces.
  991.  * 
  992.  *  This routine only actually writes the data that concerns the object
  993.  *  as a whole, such as class, and uses <somDumpSelfInt> to describe
  994.  *  the object's current state.  This approach allows readable
  995.  *  descriptions of compound objects to be constructed.
  996.  * 
  997.  *  Generally it is not necessary to override this method, if it is
  998.  *  overriden it generally must be completely replaced.
  999.  */
  1000.    SOM_ResolveD(this,SOMPIOGroupMgrAbstract,SOMObject,somDumpSelf)
  1001.     (this,level);
  1002. }
  1003.  
  1004.  
  1005. /* method: somDumpSelfInt */
  1006. void   somDumpSelfInt(long level)
  1007. {
  1008. /*
  1009.  *  Uses <SOMOutCharRoutine> to write in the current state of this object.
  1010.  *  Generally this method will need to be overridden.  When overriding
  1011.  *  it, begin by calling the parent class form of this method and then
  1012.  *  write in a description of your class's instance data. This will
  1013.  *  result in a description of all the object's instance data going
  1014.  *  from its root ancestor class to its specific class.
  1015.  */
  1016.    SOM_ResolveD(this,SOMPIOGroupMgrAbstract,SOMObject,somDumpSelfInt)
  1017.     (this,level);
  1018. }
  1019.  
  1020.  
  1021.  
  1022. };   /* SOMPIOGroupMgrAbstract */
  1023.  
  1024.  
  1025.  
  1026. #endif       /* SOM_SOMPIOGroupMgrAbstract_xh */
  1027.