home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / tolkit45.zip / os2tk45 / som / include / iogrp.xh < prev    next >
Text File  |  1999-02-22  |  28KB  |  973 lines
  1.  
  2. /*
  3.  * This file was generated by the SOM Compiler.
  4.  * FileName: iogrp.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_SOMPIOGroup_xh
  26. #define SOM_SOMPIOGroup_xh
  27.  
  28. class SOMPIOGroup;
  29.  
  30. /*
  31.  *  An IOGroup is a collection of objects which have been grouped
  32.  *  together with the intention that they will be written/read to/from
  33.  *  a storage media at the same time. For example, the group of objects
  34.  *  could be stored in the same file.
  35.  * 
  36.  *  Objects are added, located and removed from the group via an integer
  37.  *  key.
  38.  */
  39.  
  40. #define SOMPIOGroup_MajorVersion 2
  41. #define SOMPIOGroup_MinorVersion 1
  42.  
  43. /* C++ SOM defs */
  44. #include <somcls.xh>
  45. #include <somcm.xh>
  46.  
  47. /* C++ parent defs */
  48. #ifndef SOM_SOMPKeyedSet_xh
  49. #include <srkset.xh>
  50. #endif
  51.  
  52. #ifndef SOMPIOGroup_API
  53. #define SOMPIOGroup_API
  54. /*
  55.  * -- The Class API
  56.  */
  57.  
  58. /*
  59.  * Start of bindings for IDL types
  60.  */
  61.  
  62. class SOMClass;
  63. class SOMObject;
  64. class SOMPPersistentId;
  65. class SOMPPersistentObject;
  66. class SOMPIteratorHandle;
  67. typedef
  68. long  SOMPIOGroup_SOMPIOGroupKey;
  69.  
  70. #ifndef SOM_DONT_USE_SHORT_NAMES
  71. #ifndef SOMTGD_SOMPIOGroupKey
  72.     #ifdef SOMPIOGroupKey
  73.         #undef SOMPIOGroupKey
  74.         #define SOMTGD_SOMPIOGroupKey 1
  75.     #else
  76.         #define SOMPIOGroupKey SOMPIOGroup_SOMPIOGroupKey
  77.     #endif /* SOMPIOGroupKey */
  78. #endif /* SOMTGD_SOMPIOGroupKey */
  79. #endif /* SOM_DONT_USE_SHORT_NAMES */
  80.  
  81. /*
  82.  * End of bindings for IDL types.
  83.  */
  84.  
  85. /* A procedure to create the SOMPIOGroup Class */
  86. SOMEXTERN SOMClass * SOMLINK SOMPIOGroupNewClass(
  87.         integer4 majorVersion,
  88.         integer4 minorVersion);
  89.  
  90. /* The API to the SOMPIOGroup class object, and the methods it introduces. */
  91. SOMEXTERN struct SOMPIOGroupClassDataStructure {
  92.     SOMClass *classObject;
  93.     somMToken sompGetLastOffset;
  94.     somMToken sompGetNextAvailableOffset;
  95.     somMToken sompSetLastOffset;
  96.     somMToken sompFindById;
  97.     somMToken sompSetGroupName;
  98.     somMToken sompGetGroupName;
  99.     somMToken sompCount;
  100.     somMToken sompFirst;
  101.     somMToken sompNewIterator;
  102.     somMToken sompNextObjectInGroup;
  103.     somMToken sompFreeIterator;
  104.     somMToken sompAddToGroup;
  105.     somMToken sompRemoveFromGroup;
  106.     somMToken sompFindByKey;
  107. } SOMDLINK SOMPIOGroupClassData;
  108. #define _SOMPIOGroup SOMPIOGroupClassData.classObject
  109.  
  110. /* The API to parentMtabs for SOMPIOGroup, and the instance data it introduces. */
  111. SOMEXTERN struct SOMPIOGroupCClassDataStructure {
  112.     somMethodTabs parentMtab;
  113.     somDToken              instanceDataToken;
  114. } SOMDLINK SOMPIOGroupCClassData;
  115.  
  116. /*
  117.  * -- Typedefs for SOMPIOGroup Method Procedures
  118.  */
  119. SOMEXTERN {
  120. typedef long   SOMLINK somTP_SOMPIOGroup_sompCount(SOMPIOGroup *somSelf, Environment *ev);
  121. typedef somTP_SOMPIOGroup_sompCount *somTD_SOMPIOGroup_sompCount;
  122. typedef SOMObject*   SOMLINK somTP_SOMPIOGroup_sompFirst(SOMPIOGroup *somSelf, Environment *ev);
  123. typedef somTP_SOMPIOGroup_sompFirst *somTD_SOMPIOGroup_sompFirst;
  124. typedef SOMPIteratorHandle*   SOMLINK somTP_SOMPIOGroup_sompNewIterator(SOMPIOGroup *somSelf, Environment *ev);
  125. typedef somTP_SOMPIOGroup_sompNewIterator *somTD_SOMPIOGroup_sompNewIterator;
  126. typedef SOMObject*   SOMLINK somTP_SOMPIOGroup_sompNextObjectInGroup(SOMPIOGroup *somSelf, Environment *ev, 
  127.         SOMPIteratorHandle* iteratorHandle);
  128. typedef somTP_SOMPIOGroup_sompNextObjectInGroup *somTD_SOMPIOGroup_sompNextObjectInGroup;
  129. typedef void   SOMLINK somTP_SOMPIOGroup_sompFreeIterator(SOMPIOGroup *somSelf, Environment *ev, 
  130.         SOMPIteratorHandle* iteratorHandle);
  131. typedef somTP_SOMPIOGroup_sompFreeIterator *somTD_SOMPIOGroup_sompFreeIterator;
  132. typedef void   SOMLINK somTP_SOMPIOGroup_sompAddToGroup(SOMPIOGroup *somSelf, Environment *ev, 
  133.         SOMObject* newObject, 
  134.         SOMPIOGroup_SOMPIOGroupKey key);
  135. typedef somTP_SOMPIOGroup_sompAddToGroup *somTD_SOMPIOGroup_sompAddToGroup;
  136. typedef SOMObject*   SOMLINK somTP_SOMPIOGroup_sompRemoveFromGroup(SOMPIOGroup *somSelf, Environment *ev, 
  137.         SOMPIOGroup_SOMPIOGroupKey key);
  138. typedef somTP_SOMPIOGroup_sompRemoveFromGroup *somTD_SOMPIOGroup_sompRemoveFromGroup;
  139. typedef SOMObject*   SOMLINK somTP_SOMPIOGroup_sompFindByKey(SOMPIOGroup *somSelf, Environment *ev, 
  140.         SOMPIOGroup_SOMPIOGroupKey key);
  141. typedef somTP_SOMPIOGroup_sompFindByKey *somTD_SOMPIOGroup_sompFindByKey;
  142.  
  143. /*
  144.  * -- Typedefs for Reintroduced Wrapper Methods
  145.  */
  146. typedef SOMObject*   SOMLINK somTP_SOMPIOGroup_sompGetFirstObject(SOMPIOGroup *somSelf, Environment *ev);
  147. typedef somTP_SOMPIOGroup_sompGetFirstObject *somTD_SOMPIOGroup_sompGetFirstObject;
  148. typedef void   SOMLINK somTP_SOMPIOGroup_somDefaultInit(SOMPIOGroup *somSelf, 
  149.         som3InitCtrl* ctrl);
  150. typedef somTP_SOMPIOGroup_somDefaultInit *somTD_SOMPIOGroup_somDefaultInit;
  151. typedef void   SOMLINK somTP_SOMPIOGroup_somDestruct(SOMPIOGroup *somSelf, 
  152.         octet doFree, 
  153.         som3DestructCtrl* ctrl);
  154. typedef somTP_SOMPIOGroup_somDestruct *somTD_SOMPIOGroup_somDestruct;
  155. typedef void   SOMLINK somTP_SOMPIOGroup_somDefaultCopyInit(SOMPIOGroup *somSelf, 
  156.         som3InitCtrl* ctrl, 
  157.         SOMObject* fromObj);
  158. typedef somTP_SOMPIOGroup_somDefaultCopyInit *somTD_SOMPIOGroup_somDefaultCopyInit;
  159. typedef SOMPIOGroup*   SOMLINK somTP_SOMPIOGroup_somDefaultAssign(SOMPIOGroup *somSelf, 
  160.         som3AssignCtrl* ctrl, 
  161.         SOMObject* fromObj);
  162. typedef somTP_SOMPIOGroup_somDefaultAssign *somTD_SOMPIOGroup_somDefaultAssign;
  163. typedef void   SOMLINK somTP_SOMPIOGroup_somDefaultConstCopyInit(SOMPIOGroup *somSelf, 
  164.         som3InitCtrl* ctrl, 
  165.         SOMObject* fromObj);
  166. typedef somTP_SOMPIOGroup_somDefaultConstCopyInit *somTD_SOMPIOGroup_somDefaultConstCopyInit;
  167. typedef void   SOMLINK somTP_SOMPIOGroup_somDefaultVCopyInit(SOMPIOGroup *somSelf, 
  168.         som3InitCtrl* ctrl, 
  169.         SOMObject* fromObj);
  170. typedef somTP_SOMPIOGroup_somDefaultVCopyInit *somTD_SOMPIOGroup_somDefaultVCopyInit;
  171. typedef void   SOMLINK somTP_SOMPIOGroup_somDefaultConstVCopyInit(SOMPIOGroup *somSelf, 
  172.         som3InitCtrl* ctrl, 
  173.         SOMObject* fromObj);
  174. typedef somTP_SOMPIOGroup_somDefaultConstVCopyInit *somTD_SOMPIOGroup_somDefaultConstVCopyInit;
  175. typedef SOMPIOGroup*   SOMLINK somTP_SOMPIOGroup_somDefaultConstAssign(SOMPIOGroup *somSelf, 
  176.         som3AssignCtrl* ctrl, 
  177.         SOMObject* fromObj);
  178. typedef somTP_SOMPIOGroup_somDefaultConstAssign *somTD_SOMPIOGroup_somDefaultConstAssign;
  179. typedef SOMPIOGroup*   SOMLINK somTP_SOMPIOGroup_somDefaultVAssign(SOMPIOGroup *somSelf, 
  180.         som3AssignCtrl* ctrl, 
  181.         SOMObject* fromObj);
  182. typedef somTP_SOMPIOGroup_somDefaultVAssign *somTD_SOMPIOGroup_somDefaultVAssign;
  183. typedef SOMPIOGroup*   SOMLINK somTP_SOMPIOGroup_somDefaultConstVAssign(SOMPIOGroup *somSelf, 
  184.         som3AssignCtrl* ctrl, 
  185.         SOMObject* fromObj);
  186. typedef somTP_SOMPIOGroup_somDefaultConstVAssign *somTD_SOMPIOGroup_somDefaultConstVAssign;
  187. typedef void   SOMLINK somTP_SOMPIOGroup_somInit(SOMPIOGroup *somSelf);
  188. typedef somTP_SOMPIOGroup_somInit *somTD_SOMPIOGroup_somInit;
  189. typedef void   SOMLINK somTP_SOMPIOGroup_somFree(SOMPIOGroup *somSelf);
  190. typedef somTP_SOMPIOGroup_somFree *somTD_SOMPIOGroup_somFree;
  191. typedef void   SOMLINK somTP_SOMPIOGroup_somUninit(SOMPIOGroup *somSelf);
  192. typedef somTP_SOMPIOGroup_somUninit *somTD_SOMPIOGroup_somUninit;
  193. typedef SOMClass*   SOMLINK somTP_SOMPIOGroup_somGetClass(SOMPIOGroup *somSelf);
  194. typedef somTP_SOMPIOGroup_somGetClass *somTD_SOMPIOGroup_somGetClass;
  195. typedef string   SOMLINK somTP_SOMPIOGroup_somGetClassName(SOMPIOGroup *somSelf);
  196. typedef somTP_SOMPIOGroup_somGetClassName *somTD_SOMPIOGroup_somGetClassName;
  197. typedef long   SOMLINK somTP_SOMPIOGroup_somGetSize(SOMPIOGroup *somSelf);
  198. typedef somTP_SOMPIOGroup_somGetSize *somTD_SOMPIOGroup_somGetSize;
  199. typedef boolean   SOMLINK somTP_SOMPIOGroup_somIsA(SOMPIOGroup *somSelf, 
  200.         SOMClass* aClassObj);
  201. typedef somTP_SOMPIOGroup_somIsA *somTD_SOMPIOGroup_somIsA;
  202. typedef boolean   SOMLINK somTP_SOMPIOGroup_somIsInstanceOf(SOMPIOGroup *somSelf, 
  203.         SOMClass* aClassObj);
  204. typedef somTP_SOMPIOGroup_somIsInstanceOf *somTD_SOMPIOGroup_somIsInstanceOf;
  205. typedef boolean   SOMLINK somTP_SOMPIOGroup_somRespondsTo(SOMPIOGroup *somSelf, 
  206.         somId mId);
  207. typedef somTP_SOMPIOGroup_somRespondsTo *somTD_SOMPIOGroup_somRespondsTo;
  208. typedef boolean   SOMLINK somTP_SOMPIOGroup_somDispatch(SOMPIOGroup *somSelf, 
  209.         somToken* retValue, 
  210.         somId methodId, 
  211.         va_list ap);
  212. typedef somTP_SOMPIOGroup_somDispatch *somTD_SOMPIOGroup_somDispatch;
  213. typedef boolean   SOMLINK somTP_SOMPIOGroup_somClassDispatch(SOMPIOGroup *somSelf, 
  214.         SOMClass* clsObj, 
  215.         somToken* retValue, 
  216.         somId methodId, 
  217.         va_list ap);
  218. typedef somTP_SOMPIOGroup_somClassDispatch *somTD_SOMPIOGroup_somClassDispatch;
  219. typedef boolean   SOMLINK somTP_SOMPIOGroup_somCastObj(SOMPIOGroup *somSelf, 
  220.         SOMClass* cls);
  221. typedef somTP_SOMPIOGroup_somCastObj *somTD_SOMPIOGroup_somCastObj;
  222. typedef boolean   SOMLINK somTP_SOMPIOGroup_somResetObj(SOMPIOGroup *somSelf);
  223. typedef somTP_SOMPIOGroup_somResetObj *somTD_SOMPIOGroup_somResetObj;
  224. typedef void   SOMLINK somTP_SOMPIOGroup_somDispatchV(SOMPIOGroup *somSelf, 
  225.         somId methodId, 
  226.         somId descriptor, 
  227.         va_list ap);
  228. typedef somTP_SOMPIOGroup_somDispatchV *somTD_SOMPIOGroup_somDispatchV;
  229. typedef long   SOMLINK somTP_SOMPIOGroup_somDispatchL(SOMPIOGroup *somSelf, 
  230.         somId methodId, 
  231.         somId descriptor, 
  232.         va_list ap);
  233. typedef somTP_SOMPIOGroup_somDispatchL *somTD_SOMPIOGroup_somDispatchL;
  234. typedef void*   SOMLINK somTP_SOMPIOGroup_somDispatchA(SOMPIOGroup *somSelf, 
  235.         somId methodId, 
  236.         somId descriptor, 
  237.         va_list ap);
  238. typedef somTP_SOMPIOGroup_somDispatchA *somTD_SOMPIOGroup_somDispatchA;
  239. typedef double   SOMLINK somTP_SOMPIOGroup_somDispatchD(SOMPIOGroup *somSelf, 
  240.         somId methodId, 
  241.         somId descriptor, 
  242.         va_list ap);
  243. typedef somTP_SOMPIOGroup_somDispatchD *somTD_SOMPIOGroup_somDispatchD;
  244. typedef SOMObject*   SOMLINK somTP_SOMPIOGroup_somPrintSelf(SOMPIOGroup *somSelf);
  245. typedef somTP_SOMPIOGroup_somPrintSelf *somTD_SOMPIOGroup_somPrintSelf;
  246. typedef void   SOMLINK somTP_SOMPIOGroup_somDumpSelf(SOMPIOGroup *somSelf, 
  247.         long level);
  248. typedef somTP_SOMPIOGroup_somDumpSelf *somTD_SOMPIOGroup_somDumpSelf;
  249. typedef void   SOMLINK somTP_SOMPIOGroup_somDumpSelfInt(SOMPIOGroup *somSelf, 
  250.         long level);
  251. typedef somTP_SOMPIOGroup_somDumpSelfInt *somTD_SOMPIOGroup_somDumpSelfInt;
  252. }
  253.  
  254. #endif /* SOMPIOGroup_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 SOMPIOGroup
  266.  */
  267. class SOMPIOGroup : public SOMPKeyedSet
  268. {
  269. /*
  270.  *  An IOGroup is a collection of objects which have been grouped
  271.  *  together with the intention that they will be written/read to/from
  272.  *  a storage media at the same time. For example, the group of objects
  273.  *  could be stored in the same file.
  274.  * 
  275.  *  Objects are added, located and removed from the group via an integer
  276.  *  key.
  277.  */
  278. public:
  279.  
  280. // SOMPIOGroup::new creates the class object if necessary, and then uses somNewNoInit
  281. // to allocate memory and create the object. Initialization is in ctors.
  282. void *operator new(size_t)
  283. {
  284.    if (!_SOMPIOGroup) SOMPIOGroupNewClass(SOMPIOGroup_MajorVersion,SOMPIOGroup_MinorVersion);
  285.    return (void*)
  286.       SOM_Resolve(_SOMPIOGroup,SOMClass,somNewNoInit)
  287.          ((SOMClass *)((void*)_SOMPIOGroup));
  288. }
  289.  
  290. // SOMPIOGroup::delete uses somDestruct.
  291. void operator delete(void * obj)
  292. {
  293.    if (obj && *(void**)obj) {
  294.       SOM_Resolve(obj,SOMObject,somFree)
  295.          ((SOMObject*)obj);
  296.    }
  297. }
  298.  
  299. SOMPIOGroup& operator=(SOMPIOGroup& fromObj)
  300. {
  301.    this->somDefaultAssign(0,(SOMObject*)((void*)&fromObj));
  302.    return *this;
  303. }
  304.  
  305. SOMPIOGroup()
  306. {
  307.    if (*(void**)this != 
  308.        ((somParentMtabStructPtr)
  309.         (SOMPIOGroupCClassData.parentMtab))->mtab)
  310.       return;
  311.    ((SOMObject*)((void*)this))->somDefaultInit(0);
  312. }
  313.  
  314. SOMPIOGroup(SOMPIOGroup* fromObj)
  315. {
  316.    if (*(void**)this != 
  317.        ((somParentMtabStructPtr)
  318.         (SOMPIOGroupCClassData.parentMtab))->mtab)
  319.       return;
  320.    ((SOMObject*)((void*)this))->somDefaultCopyInit(0,((SOMObject*)((void*)fromObj)));
  321. }
  322.  
  323. #ifdef __IBMCPP__
  324. #pragma info(nocnv,nopar)
  325. #endif
  326. SOMPIOGroup(const SOMPIOGroup* fromObj)
  327. {
  328.    if (*(void**)this != 
  329.        ((somParentMtabStructPtr)
  330.         (SOMPIOGroupCClassData.parentMtab))->mtab)
  331.       return;
  332.    ((SOMObject*)((void*)this))->somDefaultConstCopyInit(0,((SOMObject*)((void*)fromObj)));
  333. }
  334. #ifdef __IBMCPP__
  335. #pragma info(restore)
  336. #endif
  337.  
  338.  
  339. /* method: sompCount */
  340. long   sompCount(Environment *ev)
  341. {
  342. /*
  343.  *  Returns the number of objects in this group
  344.  */
  345.    return SOM_ResolveD(this,SOMPIOGroup,SOMPIOGroup,sompCount)
  346.     (this, ev);
  347. }
  348.  
  349.  
  350. /* method: sompFirst */
  351. SOMObject*   sompFirst(Environment *ev)
  352. {
  353. /*
  354.  *  Returns the first available object in the group. The object returned
  355.  *  is not based on any ordering, it is simply the one closest at hand.
  356.  */
  357.    return SOM_ResolveD(this,SOMPIOGroup,SOMPIOGroup,sompFirst)
  358.     (this, ev);
  359. }
  360.  
  361.  
  362. /* method: sompNewIterator */
  363. SOMPIteratorHandle*   sompNewIterator(Environment *ev)
  364. {
  365. /*
  366.  *  Returns a handle which can be used with the sompNextObjectInGroup
  367.  *  method of this class to iterate through all the objects contained
  368.  *  by an instance of this class.
  369.  */
  370.    return SOM_ResolveD(this,SOMPIOGroup,SOMPIOGroup,sompNewIterator)
  371.     (this, ev);
  372. }
  373.  
  374.  
  375. /* method: sompNextObjectInGroup */
  376. SOMObject*   sompNextObjectInGroup(Environment *ev, 
  377.         SOMPIteratorHandle* iteratorHandle)
  378. {
  379. /*
  380.  *  Return the next object in the group. If there are no more objects left,
  381.  *  it returns NULL.
  382.  * 
  383.  *  Example use:
  384.  * 
  385.  *  hit = _sompNewIterator(myGroup)
  386.  *  while (obj = _sompNextObjectInGroup(hit)) {
  387.  *     ...
  388.  *     use obj
  389.  *     ...
  390.  *     }
  391.  *  _sompFreeIterator(hit);
  392.  */
  393.    return SOM_ResolveD(this,SOMPIOGroup,SOMPIOGroup,sompNextObjectInGroup)
  394.     (this, ev,iteratorHandle);
  395. }
  396.  
  397.  
  398. /* method: sompFreeIterator */
  399. void   sompFreeIterator(Environment *ev, 
  400.         SOMPIteratorHandle* iteratorHandle)
  401. {
  402. /*
  403.  *  Free the resources used by the given iterator.
  404.  */
  405.    SOM_ResolveD(this,SOMPIOGroup,SOMPIOGroup,sompFreeIterator)
  406.     (this, ev,iteratorHandle);
  407. }
  408.  
  409.  
  410. /* method: sompAddToGroup */
  411. void   sompAddToGroup(Environment *ev, 
  412.         SOMObject* newObject, 
  413.         SOMPIOGroup_SOMPIOGroupKey key)
  414. {
  415. /*
  416.  *  Adds the given object to this group of objects. The given key for
  417.  *  the new object must be unique among all the other objects in
  418.  *  this group.
  419.  */
  420.    SOM_ResolveD(this,SOMPIOGroup,SOMPIOGroup,sompAddToGroup)
  421.     (this, ev,newObject,key);
  422. }
  423.  
  424.  
  425. /* method: sompRemoveFromGroup */
  426. SOMObject*   sompRemoveFromGroup(Environment *ev, 
  427.         SOMPIOGroup_SOMPIOGroupKey key)
  428. {
  429. /*
  430.  *  Remove from the group and return the object with the given key value.
  431.  */
  432.    return SOM_ResolveD(this,SOMPIOGroup,SOMPIOGroup,sompRemoveFromGroup)
  433.     (this, ev,key);
  434. }
  435.  
  436.  
  437. /* method: sompFindByKey */
  438. SOMObject*   sompFindByKey(Environment *ev, 
  439.         SOMPIOGroup_SOMPIOGroupKey key)
  440. {
  441. /*
  442.  *  Return the object with the given key value.
  443.  */
  444.    return SOM_ResolveD(this,SOMPIOGroup,SOMPIOGroup,sompFindByKey)
  445.     (this, ev,key);
  446. }
  447.  
  448.  
  449. /*
  450.  * Reintroduce inherited methods
  451.  */
  452.  
  453. /* method: sompGetFirstObject */
  454. SOMObject*   sompGetFirstObject(Environment *ev)
  455. {
  456. /*
  457.  *  Get first object in this set.
  458.  *  If set is empty, returns NULL.
  459.  */
  460.    return SOM_ResolveD(this,SOMPIOGroup,SOMPKeyedSet,sompGetFirstObject)
  461.     (this, ev);
  462. }
  463.  
  464.  
  465. /* initializer method: somDefaultInit */
  466. void   somDefaultInit(som3InitCtrl* ctrl)
  467. {
  468. /*
  469.  *  A default initializer for a SOM object. Passing a null ctrl
  470.  *  indicates to the receiver that its class is the class of the
  471.  *  object being initialized, whereby the initializer will determine
  472.  *  an appropriate control structure.
  473.  */
  474.    SOM_ResolveD(this,SOMPIOGroup,SOMObject,somDefaultInit)
  475.     (this,ctrl);
  476. }
  477.  
  478.  
  479. /* method: somDestruct */
  480. void   somDestruct(octet doFree, 
  481.         som3DestructCtrl* ctrl)
  482. {
  483. /*
  484.  *  The default destructor for a SOM object. A nonzero <doFree>
  485.  *  indicates that the object storage should be freed by the
  486.  *  object's class (via somDeallocate) after uninitialization.
  487.  *  As with somDefaultInit, a null ctrl can be passed.
  488.  */
  489.    SOM_ResolveD(this,SOMPIOGroup,SOMObject,somDestruct)
  490.     (this,doFree,ctrl);
  491. }
  492.  
  493.  
  494. /* initializer method: somDefaultCopyInit */
  495. void   somDefaultCopyInit(som3InitCtrl* ctrl, 
  496.         SOMObject* fromObj)
  497. {
  498. /*
  499.  *  A default copy constructor. Use this to make copies of objects for
  500.  *  calling methods with "by-value" argument semantics.
  501.  */
  502.    SOM_ResolveD(this,SOMPIOGroup,SOMObject,somDefaultCopyInit)
  503.     (this,ctrl,fromObj);
  504. }
  505.  
  506.  
  507. /* method: somDefaultAssign */
  508. SOMPIOGroup*  somDefaultAssign(som3AssignCtrl* ctrl, 
  509.         SOMObject* fromObj)
  510. {
  511. /*
  512.  *  A default assignment operator. Use this to "assign" the state of one
  513.  *  object to another.
  514.  */
  515.    return SOM_ResolveD(this,SOMPIOGroup,SOMObject,somDefaultAssign)
  516.     (this,ctrl,fromObj);
  517. }
  518.  
  519.  
  520. /* initializer method: somDefaultConstCopyInit */
  521. void   somDefaultConstCopyInit(som3InitCtrl* ctrl, 
  522.         SOMObject* fromObj)
  523. {
  524. /*
  525.  *  A default copy constructor that uses a const fromObj.
  526.  */
  527.    SOM_ResolveD(this,SOMPIOGroup,SOMObject,somDefaultConstCopyInit)
  528.     (this,ctrl,fromObj);
  529. }
  530.  
  531.  
  532. /* initializer method: somDefaultVCopyInit */
  533. void   somDefaultVCopyInit(som3InitCtrl* ctrl, 
  534.         SOMObject* fromObj)
  535. {
  536. /*
  537.  *  A default copy constructor that uses a volatile fromObj.
  538.  */
  539.    SOM_ResolveD(this,SOMPIOGroup,SOMObject,somDefaultVCopyInit)
  540.     (this,ctrl,fromObj);
  541. }
  542.  
  543.  
  544. /* initializer method: somDefaultConstVCopyInit */
  545. void   somDefaultConstVCopyInit(som3InitCtrl* ctrl, 
  546.         SOMObject* fromObj)
  547. {
  548. /*
  549.  *  A default copy constructor that uses a const volatile fromObj.
  550.  */
  551.    SOM_ResolveD(this,SOMPIOGroup,SOMObject,somDefaultConstVCopyInit)
  552.     (this,ctrl,fromObj);
  553. }
  554.  
  555.  
  556. /* method: somDefaultConstAssign */
  557. SOMPIOGroup*  somDefaultConstAssign(som3AssignCtrl* ctrl, 
  558.         SOMObject* fromObj)
  559. {
  560. /*
  561.  *  A default assignment operator that uses a const fromObj.
  562.  */
  563.    return SOM_ResolveD(this,SOMPIOGroup,SOMObject,somDefaultConstAssign)
  564.     (this,ctrl,fromObj);
  565. }
  566.  
  567.  
  568. /* method: somDefaultVAssign */
  569. SOMPIOGroup*  somDefaultVAssign(som3AssignCtrl* ctrl, 
  570.         SOMObject* fromObj)
  571. {
  572. /*
  573.  *  A default assignment operator that uses a volatile fromObj.
  574.  */
  575.    return SOM_ResolveD(this,SOMPIOGroup,SOMObject,somDefaultVAssign)
  576.     (this,ctrl,fromObj);
  577. }
  578.  
  579.  
  580. /* method: somDefaultConstVAssign */
  581. SOMPIOGroup*  somDefaultConstVAssign(som3AssignCtrl* ctrl, 
  582.         SOMObject* fromObj)
  583. {
  584. /*
  585.  *  A default assignment operator that uses a const volatile fromObj.
  586.  */
  587.    return SOM_ResolveD(this,SOMPIOGroup,SOMObject,somDefaultConstVAssign)
  588.     (this,ctrl,fromObj);
  589. }
  590.  
  591.  
  592. /* method: somInit */
  593. void   somInit()
  594. {
  595. /*
  596.  *  Obsolete but still supported. Override somDefaultInit instead of somInit.
  597.  */
  598.    SOM_ResolveD(this,SOMPIOGroup,SOMObject,somInit)
  599.     (this);
  600. }
  601.  
  602.  
  603. /* method: somFree */
  604. void   somFree()
  605. {
  606. /*
  607.  *  Use as directed by framework implementations.
  608.  */
  609.    SOM_ResolveD(this,SOMPIOGroup,SOMObject,somFree)
  610.     (this);
  611. }
  612.  
  613.  
  614. /* method: somUninit */
  615. void   somUninit()
  616. {
  617. /*
  618.  *  Obsolete but still supported. Override somDestruct instead of somUninit.
  619.  */
  620.    SOM_ResolveD(this,SOMPIOGroup,SOMObject,somUninit)
  621.     (this);
  622. }
  623.  
  624.  
  625. /* method: somGetClass */
  626. SOMClass*   somGetClass()
  627. {
  628. /*
  629.  *  Return the receiver's class.
  630.  */
  631.    return SOM_ResolveD(this,SOMPIOGroup,SOMObject,somGetClass)
  632.     (this);
  633. }
  634.  
  635.  
  636. /* method: somGetClassName */
  637. string   somGetClassName()
  638. {
  639. /*
  640.  *  Return the name of the receiver's class.
  641.  */
  642.    return SOM_ResolveD(this,SOMPIOGroup,SOMObject,somGetClassName)
  643.     (this);
  644. }
  645.  
  646.  
  647. /* method: somGetSize */
  648. long   somGetSize()
  649. {
  650. /*
  651.  *  Return the size of the receiver.
  652.  */
  653.    return SOM_ResolveD(this,SOMPIOGroup,SOMObject,somGetSize)
  654.     (this);
  655. }
  656.  
  657.  
  658. /* method: somIsA */
  659. boolean   somIsA(SOMClass* aClassObj)
  660. {
  661. /*
  662.  *  Returns 1 (true) if the receiver responds to methods
  663.  *  introduced by <aClassObj>, and 0 (false) otherwise.
  664.  */
  665.    return SOM_ResolveD(this,SOMPIOGroup,SOMObject,somIsA)
  666.     (this,aClassObj);
  667. }
  668.  
  669.  
  670. /* method: somIsInstanceOf */
  671. boolean   somIsInstanceOf(SOMClass* aClassObj)
  672. {
  673. /*
  674.  *  Returns 1 (true) if the receiver is an instance of
  675.  *  <aClassObj> and 0 (false) otherwise.
  676.  */
  677.    return SOM_ResolveD(this,SOMPIOGroup,SOMObject,somIsInstanceOf)
  678.     (this,aClassObj);
  679. }
  680.  
  681.  
  682. /* method: somRespondsTo */
  683. boolean   somRespondsTo(somId mId)
  684. {
  685. /*
  686.  *  Returns 1 (true) if the indicated method can be invoked
  687.  *  on the receiver and 0 (false) otherwise.
  688.  */
  689.    return SOM_ResolveD(this,SOMPIOGroup,SOMObject,somRespondsTo)
  690.     (this,mId);
  691. }
  692.  
  693.  
  694. /* va_list method: somDispatch */
  695.  
  696. /*
  697.  *  This method provides a generic, class-specific dispatch mechanism.
  698.  *  It accepts as input <retValue> a pointer to the memory area to be
  699.  *  loaded with the result of dispatching the method indicated by
  700.  *  <methodId> using the arguments in <ap>. <ap> contains the object
  701.  *  on which the method is to be invoked as the first argument.
  702.  */
  703. /* the va_list invocation form */
  704. boolean   SOMPIOGroup_somDispatch(somToken* retValue, 
  705.         somId methodId, 
  706.         va_list ap)
  707. {return SOM_ResolveD(this,SOMPIOGroup,SOMObject,somDispatch)
  708.     (this,retValue,methodId,ap);
  709. }
  710.  
  711. /* the varargs invocation form */
  712. boolean   somDispatch(somToken* retValue, 
  713.         somId methodId, 
  714.         ...)
  715. {
  716. /*
  717.  *  This method provides a generic, class-specific dispatch mechanism.
  718.  *  It accepts as input <retValue> a pointer to the memory area to be
  719.  *  loaded with the result of dispatching the method indicated by
  720.  *  <methodId> using the arguments in <ap>. <ap> contains the object
  721.  *  on which the method is to be invoked as the first argument.
  722.  */
  723.    va_list ap;
  724.    va_start(ap, methodId);
  725.    boolean __somResult = 
  726.       SOM_ResolveD(this,SOMPIOGroup,SOMObject,somDispatch)
  727.     (this,retValue,methodId,ap);
  728.    va_end(ap);
  729.    return __somResult;
  730. }
  731.  
  732.  
  733. /* va_list method: somClassDispatch */
  734.  
  735. /*
  736.  *  Like somDispatch, but method resolution for static methods is done
  737.  *  according to the clsObj instance method table.
  738.  */
  739. /* the va_list invocation form */
  740. boolean   SOMPIOGroup_somClassDispatch(SOMClass* clsObj, 
  741.         somToken* retValue, 
  742.         somId methodId, 
  743.         va_list ap)
  744. {return SOM_ResolveD(this,SOMPIOGroup,SOMObject,somClassDispatch)
  745.     (this,clsObj,retValue,methodId,ap);
  746. }
  747.  
  748. /* the varargs invocation form */
  749. boolean   somClassDispatch(SOMClass* clsObj, 
  750.         somToken* retValue, 
  751.         somId methodId, 
  752.         ...)
  753. {
  754. /*
  755.  *  Like somDispatch, but method resolution for static methods is done
  756.  *  according to the clsObj instance method table.
  757.  */
  758.    va_list ap;
  759.    va_start(ap, methodId);
  760.    boolean __somResult = 
  761.       SOM_ResolveD(this,SOMPIOGroup,SOMObject,somClassDispatch)
  762.     (this,clsObj,retValue,methodId,ap);
  763.    va_end(ap);
  764.    return __somResult;
  765. }
  766.  
  767.  
  768. /* method: somCastObj */
  769. boolean   somCastObj(SOMClass* cls)
  770. {
  771. /*
  772.  *  cast the receiving object to cls (which must be an ancestor of the
  773.  *  objects true class. Returns true on success.
  774.  */
  775.    return SOM_ResolveD(this,SOMPIOGroup,SOMObject,somCastObj)
  776.     (this,cls);
  777. }
  778.  
  779.  
  780. /* method: somResetObj */
  781. boolean   somResetObj()
  782. {
  783. /*
  784.  *  reset an object to its true class. Returns true always.
  785.  */
  786.    return SOM_ResolveD(this,SOMPIOGroup,SOMObject,somResetObj)
  787.     (this);
  788. }
  789.  
  790.  
  791. /* va_list method: somDispatchV */
  792.  
  793. /*
  794.  *  Obsolete. Use somDispatch instead.
  795.  */
  796. /* the va_list invocation form */
  797. void   SOMPIOGroup_somDispatchV(somId methodId, 
  798.         somId descriptor, 
  799.         va_list ap)
  800. {   SOM_ResolveD(this,SOMPIOGroup,SOMObject,somDispatchV)
  801.     (this,methodId,descriptor,ap);
  802. }
  803.  
  804. /* the varargs invocation form */
  805. void   somDispatchV(somId methodId, 
  806.         somId descriptor, 
  807.         ...)
  808. {
  809. /*
  810.  *  Obsolete. Use somDispatch instead.
  811.  */
  812.    va_list ap;
  813.    va_start(ap, descriptor);
  814.    SOM_ResolveD(this,SOMPIOGroup,SOMObject,somDispatchV)
  815.     (this,methodId,descriptor,ap);
  816.    va_end(ap);
  817. }
  818.  
  819.  
  820. /* va_list method: somDispatchL */
  821.  
  822. /*
  823.  *  Obsolete. Use somDispatch instead.
  824.  */
  825. /* the va_list invocation form */
  826. long   SOMPIOGroup_somDispatchL(somId methodId, 
  827.         somId descriptor, 
  828.         va_list ap)
  829. {return SOM_ResolveD(this,SOMPIOGroup,SOMObject,somDispatchL)
  830.     (this,methodId,descriptor,ap);
  831. }
  832.  
  833. /* the varargs invocation form */
  834. long   somDispatchL(somId methodId, 
  835.         somId descriptor, 
  836.         ...)
  837. {
  838. /*
  839.  *  Obsolete. Use somDispatch instead.
  840.  */
  841.    va_list ap;
  842.    va_start(ap, descriptor);
  843.    long __somResult = 
  844.       SOM_ResolveD(this,SOMPIOGroup,SOMObject,somDispatchL)
  845.     (this,methodId,descriptor,ap);
  846.    va_end(ap);
  847.    return __somResult;
  848. }
  849.  
  850.  
  851. /* va_list method: somDispatchA */
  852.  
  853. /*
  854.  *  Obsolete. Use somDispatch instead.
  855.  */
  856. /* the va_list invocation form */
  857. void*   SOMPIOGroup_somDispatchA(somId methodId, 
  858.         somId descriptor, 
  859.         va_list ap)
  860. {return SOM_ResolveD(this,SOMPIOGroup,SOMObject,somDispatchA)
  861.     (this,methodId,descriptor,ap);
  862. }
  863.  
  864. /* the varargs invocation form */
  865. void*   somDispatchA(somId methodId, 
  866.         somId descriptor, 
  867.         ...)
  868. {
  869. /*
  870.  *  Obsolete. Use somDispatch instead.
  871.  */
  872.    va_list ap;
  873.    va_start(ap, descriptor);
  874.    void* __somResult = 
  875.       SOM_ResolveD(this,SOMPIOGroup,SOMObject,somDispatchA)
  876.     (this,methodId,descriptor,ap);
  877.    va_end(ap);
  878.    return __somResult;
  879. }
  880.  
  881.  
  882. /* va_list method: somDispatchD */
  883.  
  884. /*
  885.  *  Obsolete. Use somDispatch instead.
  886.  */
  887. /* the va_list invocation form */
  888. double   SOMPIOGroup_somDispatchD(somId methodId, 
  889.         somId descriptor, 
  890.         va_list ap)
  891. {return SOM_ResolveD(this,SOMPIOGroup,SOMObject,somDispatchD)
  892.     (this,methodId,descriptor,ap);
  893. }
  894.  
  895. /* the varargs invocation form */
  896. double   somDispatchD(somId methodId, 
  897.         somId descriptor, 
  898.         ...)
  899. {
  900. /*
  901.  *  Obsolete. Use somDispatch instead.
  902.  */
  903.    va_list ap;
  904.    va_start(ap, descriptor);
  905.    double __somResult = 
  906.       SOM_ResolveD(this,SOMPIOGroup,SOMObject,somDispatchD)
  907.     (this,methodId,descriptor,ap);
  908.    va_end(ap);
  909.    return __somResult;
  910. }
  911.  
  912.  
  913. /* method: somPrintSelf */
  914. SOMObject*   somPrintSelf()
  915. {
  916. /*
  917.  *  Uses <SOMOutCharRoutine> to write a brief string with identifying
  918.  *  information about this object.  The default implementation just gives
  919.  *  the object's class name and its address in memory.
  920.  *  <self> is returned.
  921.  */
  922.    return SOM_ResolveD(this,SOMPIOGroup,SOMObject,somPrintSelf)
  923.     (this);
  924. }
  925.  
  926.  
  927. /* method: somDumpSelf */
  928. void   somDumpSelf(long level)
  929. {
  930. /*
  931.  *  Uses <SOMOutCharRoutine> to write a detailed description of this object
  932.  *  and its current state.
  933.  * 
  934.  *  <level> indicates the nesting level for describing compound objects
  935.  *  it must be greater than or equal to zero.  All lines in the
  936.  *  description will be preceeded by <2*level> spaces.
  937.  * 
  938.  *  This routine only actually writes the data that concerns the object
  939.  *  as a whole, such as class, and uses <somDumpSelfInt> to describe
  940.  *  the object's current state.  This approach allows readable
  941.  *  descriptions of compound objects to be constructed.
  942.  * 
  943.  *  Generally it is not necessary to override this method, if it is
  944.  *  overriden it generally must be completely replaced.
  945.  */
  946.    SOM_ResolveD(this,SOMPIOGroup,SOMObject,somDumpSelf)
  947.     (this,level);
  948. }
  949.  
  950.  
  951. /* method: somDumpSelfInt */
  952. void   somDumpSelfInt(long level)
  953. {
  954. /*
  955.  *  Uses <SOMOutCharRoutine> to write in the current state of this object.
  956.  *  Generally this method will need to be overridden.  When overriding
  957.  *  it, begin by calling the parent class form of this method and then
  958.  *  write in a description of your class's instance data. This will
  959.  *  result in a description of all the object's instance data going
  960.  *  from its root ancestor class to its specific class.
  961.  */
  962.    SOM_ResolveD(this,SOMPIOGroup,SOMObject,somDumpSelfInt)
  963.     (this,level);
  964. }
  965.  
  966.  
  967.  
  968. };   /* SOMPIOGroup */
  969.  
  970.  
  971.  
  972. #endif       /* SOM_SOMPIOGroup_xh */
  973.