home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / tolkit45.zip / os2tk45 / som / include / tsetitr.xh < prev    next >
Text File  |  1999-02-22  |  26KB  |  857 lines
  1.  
  2. /*
  3.  * This file was generated by the SOM Compiler.
  4.  * FileName: tsetitr.xh.
  5.  * Generated using:
  6.  *     SOM Precompiler somipc: 2.29.1.17
  7.  *     SOM Emitter emitxh: 2.47
  8.  */
  9.  
  10. /*
  11.  *    COMPONENT_NAME: somuc
  12.  * 
  13.  *    ORIGINS: 82, 81, 27
  14.  * 
  15.  * 
  16.  *     25H7912  (C)  COPYRIGHT International Business Machines Corp. 1992,1996,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.  *    Copyright ⌐ 1988, 1989 Apple Computer, Inc. All rights reserved.
  23.  * 
  24.  * CLASS_NAME: somf_TSetIterator
  25.  * 
  26.  * DESCRIPTION: An iterator for TSet's that will iterate over all of the objects
  27.  *              in a set.
  28.  * 
  29.  */
  30.  
  31.  
  32. #ifndef SOM_somf_TSetIterator_xh
  33. #define SOM_somf_TSetIterator_xh
  34.  
  35. class somf_TSetIterator;
  36.  
  37. #define somf_TSetIterator_MajorVersion 2
  38. #define somf_TSetIterator_MinorVersion 1
  39.  
  40. /* C++ SOM defs */
  41. #include <somcls.xh>
  42. #include <somcm.xh>
  43.  
  44. /* C++ parent defs */
  45. #ifndef SOM_somf_TIterator_xh
  46. #include <titeratr.xh>
  47. #endif
  48.  
  49. #ifndef somf_TSetIterator_API
  50. #define somf_TSetIterator_API
  51. /*
  52.  * -- The Class API
  53.  */
  54.  
  55. /*
  56.  * Start of bindings for IDL types
  57.  */
  58.  
  59. class SOMClass;
  60. class SOMObject;
  61. class somf_MCollectible;
  62. class somf_TSet;
  63. class TSAssoc;
  64.  
  65. /*
  66.  * End of bindings for IDL types.
  67.  */
  68.  
  69. /*
  70.  * Passthru lines: File: "C.xh", "after"
  71.  */
  72.  
  73. #include <tset.xh>
  74. #include <mcollect.xh>
  75.  
  76. /* A procedure to create the somf_TSetIterator Class */
  77. SOMEXTERN SOMClass * SOMLINK somf_TSetIteratorNewClass(
  78.         integer4 majorVersion,
  79.         integer4 minorVersion);
  80.  
  81. /* The API to the somf_TSetIterator class object, and the methods it introduces. */
  82. SOMEXTERN struct somf_TSetIteratorClassDataStructure {
  83.     SOMClass *classObject;
  84.     somMToken somfTSetIteratorInit;
  85. } SOMDLINK somf_TSetIteratorClassData;
  86. #define _somf_TSetIterator somf_TSetIteratorClassData.classObject
  87.  
  88. /* The API to parentMtabs for somf_TSetIterator, and the instance data it introduces. */
  89. SOMEXTERN struct somf_TSetIteratorCClassDataStructure {
  90.     somMethodTabs parentMtab;
  91.     somDToken              instanceDataToken;
  92. } SOMDLINK somf_TSetIteratorCClassData;
  93.  
  94. /*
  95.  * -- Typedefs for somf_TSetIterator Method Procedures
  96.  */
  97. SOMEXTERN {
  98. typedef somf_TSetIterator*   SOMLINK somTP_somf_TSetIterator_somfTSetIteratorInit(somf_TSetIterator *somSelf, Environment *ev, 
  99.         somf_TSet* h);
  100. typedef somTP_somf_TSetIterator_somfTSetIteratorInit *somTD_somf_TSetIterator_somfTSetIteratorInit;
  101.  
  102. /*
  103.  * -- Typedefs for Reintroduced Wrapper Methods
  104.  */
  105. typedef somf_MCollectible*   SOMLINK somTP_somf_TSetIterator_somfNext(somf_TSetIterator *somSelf, Environment *ev);
  106. typedef somTP_somf_TSetIterator_somfNext *somTD_somf_TSetIterator_somfNext;
  107. typedef somf_MCollectible*   SOMLINK somTP_somf_TSetIterator_somfFirst(somf_TSetIterator *somSelf, Environment *ev);
  108. typedef somTP_somf_TSetIterator_somfFirst *somTD_somf_TSetIterator_somfFirst;
  109. typedef void   SOMLINK somTP_somf_TSetIterator_somfRemove(somf_TSetIterator *somSelf, Environment *ev);
  110. typedef somTP_somf_TSetIterator_somfRemove *somTD_somf_TSetIterator_somfRemove;
  111. typedef void   SOMLINK somTP_somf_TSetIterator_somDefaultInit(somf_TSetIterator *somSelf, 
  112.         som3InitCtrl* ctrl);
  113. typedef somTP_somf_TSetIterator_somDefaultInit *somTD_somf_TSetIterator_somDefaultInit;
  114. typedef void   SOMLINK somTP_somf_TSetIterator_somDestruct(somf_TSetIterator *somSelf, 
  115.         octet doFree, 
  116.         som3DestructCtrl* ctrl);
  117. typedef somTP_somf_TSetIterator_somDestruct *somTD_somf_TSetIterator_somDestruct;
  118. typedef void   SOMLINK somTP_somf_TSetIterator_somDefaultCopyInit(somf_TSetIterator *somSelf, 
  119.         som3InitCtrl* ctrl, 
  120.         SOMObject* fromObj);
  121. typedef somTP_somf_TSetIterator_somDefaultCopyInit *somTD_somf_TSetIterator_somDefaultCopyInit;
  122. typedef somf_TSetIterator*   SOMLINK somTP_somf_TSetIterator_somDefaultAssign(somf_TSetIterator *somSelf, 
  123.         som3AssignCtrl* ctrl, 
  124.         SOMObject* fromObj);
  125. typedef somTP_somf_TSetIterator_somDefaultAssign *somTD_somf_TSetIterator_somDefaultAssign;
  126. typedef void   SOMLINK somTP_somf_TSetIterator_somDefaultConstCopyInit(somf_TSetIterator *somSelf, 
  127.         som3InitCtrl* ctrl, 
  128.         SOMObject* fromObj);
  129. typedef somTP_somf_TSetIterator_somDefaultConstCopyInit *somTD_somf_TSetIterator_somDefaultConstCopyInit;
  130. typedef void   SOMLINK somTP_somf_TSetIterator_somDefaultVCopyInit(somf_TSetIterator *somSelf, 
  131.         som3InitCtrl* ctrl, 
  132.         SOMObject* fromObj);
  133. typedef somTP_somf_TSetIterator_somDefaultVCopyInit *somTD_somf_TSetIterator_somDefaultVCopyInit;
  134. typedef void   SOMLINK somTP_somf_TSetIterator_somDefaultConstVCopyInit(somf_TSetIterator *somSelf, 
  135.         som3InitCtrl* ctrl, 
  136.         SOMObject* fromObj);
  137. typedef somTP_somf_TSetIterator_somDefaultConstVCopyInit *somTD_somf_TSetIterator_somDefaultConstVCopyInit;
  138. typedef somf_TSetIterator*   SOMLINK somTP_somf_TSetIterator_somDefaultConstAssign(somf_TSetIterator *somSelf, 
  139.         som3AssignCtrl* ctrl, 
  140.         SOMObject* fromObj);
  141. typedef somTP_somf_TSetIterator_somDefaultConstAssign *somTD_somf_TSetIterator_somDefaultConstAssign;
  142. typedef somf_TSetIterator*   SOMLINK somTP_somf_TSetIterator_somDefaultVAssign(somf_TSetIterator *somSelf, 
  143.         som3AssignCtrl* ctrl, 
  144.         SOMObject* fromObj);
  145. typedef somTP_somf_TSetIterator_somDefaultVAssign *somTD_somf_TSetIterator_somDefaultVAssign;
  146. typedef somf_TSetIterator*   SOMLINK somTP_somf_TSetIterator_somDefaultConstVAssign(somf_TSetIterator *somSelf, 
  147.         som3AssignCtrl* ctrl, 
  148.         SOMObject* fromObj);
  149. typedef somTP_somf_TSetIterator_somDefaultConstVAssign *somTD_somf_TSetIterator_somDefaultConstVAssign;
  150. typedef void   SOMLINK somTP_somf_TSetIterator_somInit(somf_TSetIterator *somSelf);
  151. typedef somTP_somf_TSetIterator_somInit *somTD_somf_TSetIterator_somInit;
  152. typedef void   SOMLINK somTP_somf_TSetIterator_somFree(somf_TSetIterator *somSelf);
  153. typedef somTP_somf_TSetIterator_somFree *somTD_somf_TSetIterator_somFree;
  154. typedef void   SOMLINK somTP_somf_TSetIterator_somUninit(somf_TSetIterator *somSelf);
  155. typedef somTP_somf_TSetIterator_somUninit *somTD_somf_TSetIterator_somUninit;
  156. typedef SOMClass*   SOMLINK somTP_somf_TSetIterator_somGetClass(somf_TSetIterator *somSelf);
  157. typedef somTP_somf_TSetIterator_somGetClass *somTD_somf_TSetIterator_somGetClass;
  158. typedef string   SOMLINK somTP_somf_TSetIterator_somGetClassName(somf_TSetIterator *somSelf);
  159. typedef somTP_somf_TSetIterator_somGetClassName *somTD_somf_TSetIterator_somGetClassName;
  160. typedef long   SOMLINK somTP_somf_TSetIterator_somGetSize(somf_TSetIterator *somSelf);
  161. typedef somTP_somf_TSetIterator_somGetSize *somTD_somf_TSetIterator_somGetSize;
  162. typedef boolean   SOMLINK somTP_somf_TSetIterator_somIsA(somf_TSetIterator *somSelf, 
  163.         SOMClass* aClassObj);
  164. typedef somTP_somf_TSetIterator_somIsA *somTD_somf_TSetIterator_somIsA;
  165. typedef boolean   SOMLINK somTP_somf_TSetIterator_somIsInstanceOf(somf_TSetIterator *somSelf, 
  166.         SOMClass* aClassObj);
  167. typedef somTP_somf_TSetIterator_somIsInstanceOf *somTD_somf_TSetIterator_somIsInstanceOf;
  168. typedef boolean   SOMLINK somTP_somf_TSetIterator_somRespondsTo(somf_TSetIterator *somSelf, 
  169.         somId mId);
  170. typedef somTP_somf_TSetIterator_somRespondsTo *somTD_somf_TSetIterator_somRespondsTo;
  171. typedef boolean   SOMLINK somTP_somf_TSetIterator_somDispatch(somf_TSetIterator *somSelf, 
  172.         somToken* retValue, 
  173.         somId methodId, 
  174.         va_list ap);
  175. typedef somTP_somf_TSetIterator_somDispatch *somTD_somf_TSetIterator_somDispatch;
  176. typedef boolean   SOMLINK somTP_somf_TSetIterator_somClassDispatch(somf_TSetIterator *somSelf, 
  177.         SOMClass* clsObj, 
  178.         somToken* retValue, 
  179.         somId methodId, 
  180.         va_list ap);
  181. typedef somTP_somf_TSetIterator_somClassDispatch *somTD_somf_TSetIterator_somClassDispatch;
  182. typedef boolean   SOMLINK somTP_somf_TSetIterator_somCastObj(somf_TSetIterator *somSelf, 
  183.         SOMClass* cls);
  184. typedef somTP_somf_TSetIterator_somCastObj *somTD_somf_TSetIterator_somCastObj;
  185. typedef boolean   SOMLINK somTP_somf_TSetIterator_somResetObj(somf_TSetIterator *somSelf);
  186. typedef somTP_somf_TSetIterator_somResetObj *somTD_somf_TSetIterator_somResetObj;
  187. typedef void   SOMLINK somTP_somf_TSetIterator_somDispatchV(somf_TSetIterator *somSelf, 
  188.         somId methodId, 
  189.         somId descriptor, 
  190.         va_list ap);
  191. typedef somTP_somf_TSetIterator_somDispatchV *somTD_somf_TSetIterator_somDispatchV;
  192. typedef long   SOMLINK somTP_somf_TSetIterator_somDispatchL(somf_TSetIterator *somSelf, 
  193.         somId methodId, 
  194.         somId descriptor, 
  195.         va_list ap);
  196. typedef somTP_somf_TSetIterator_somDispatchL *somTD_somf_TSetIterator_somDispatchL;
  197. typedef void*   SOMLINK somTP_somf_TSetIterator_somDispatchA(somf_TSetIterator *somSelf, 
  198.         somId methodId, 
  199.         somId descriptor, 
  200.         va_list ap);
  201. typedef somTP_somf_TSetIterator_somDispatchA *somTD_somf_TSetIterator_somDispatchA;
  202. typedef double   SOMLINK somTP_somf_TSetIterator_somDispatchD(somf_TSetIterator *somSelf, 
  203.         somId methodId, 
  204.         somId descriptor, 
  205.         va_list ap);
  206. typedef somTP_somf_TSetIterator_somDispatchD *somTD_somf_TSetIterator_somDispatchD;
  207. typedef SOMObject*   SOMLINK somTP_somf_TSetIterator_somPrintSelf(somf_TSetIterator *somSelf);
  208. typedef somTP_somf_TSetIterator_somPrintSelf *somTD_somf_TSetIterator_somPrintSelf;
  209. typedef void   SOMLINK somTP_somf_TSetIterator_somDumpSelf(somf_TSetIterator *somSelf, 
  210.         long level);
  211. typedef somTP_somf_TSetIterator_somDumpSelf *somTD_somf_TSetIterator_somDumpSelf;
  212. typedef void   SOMLINK somTP_somf_TSetIterator_somDumpSelfInt(somf_TSetIterator *somSelf, 
  213.         long level);
  214. typedef somTP_somf_TSetIterator_somDumpSelfInt *somTD_somf_TSetIterator_somDumpSelfInt;
  215. }
  216.  
  217. #endif /* somf_TSetIterator_API */
  218.  
  219.  
  220. /*
  221.  * -- This emitter treats Method Tokens as Thunks by default.
  222.  * -- Use the sc modifier "nothunks" to change this default
  223.  */
  224. #undef somresolve_
  225. #define somresolve_(obj,mToken) ((somMethodProc*)((void)obj, mToken))
  226.  
  227. /*
  228.  * -- The C++ Wrapper Class for somf_TSetIterator
  229.  */
  230. class somf_TSetIterator : public somf_TIterator
  231. {
  232. public:
  233.  
  234. // somf_TSetIterator::new creates the class object if necessary, and then uses somNewNoInit
  235. // to allocate memory and create the object. Initialization is in ctors.
  236. void *operator new(size_t)
  237. {
  238.    if (!_somf_TSetIterator) somf_TSetIteratorNewClass(somf_TSetIterator_MajorVersion,somf_TSetIterator_MinorVersion);
  239.    return (void*)
  240.       SOM_Resolve(_somf_TSetIterator,SOMClass,somNewNoInit)
  241.          ((SOMClass *)((void*)_somf_TSetIterator));
  242. }
  243.  
  244. // somf_TSetIterator::delete uses somDestruct.
  245. void operator delete(void * obj)
  246. {
  247.    if (obj && *(void**)obj) {
  248.       SOM_Resolve(obj,SOMObject,somFree)
  249.          ((SOMObject*)obj);
  250.    }
  251. }
  252.  
  253. somf_TSetIterator& operator=(somf_TSetIterator& fromObj)
  254. {
  255.    this->somDefaultAssign(0,(SOMObject*)((void*)&fromObj));
  256.    return *this;
  257. }
  258.  
  259. somf_TSetIterator()
  260. {
  261.    if (*(void**)this != 
  262.        ((somParentMtabStructPtr)
  263.         (somf_TSetIteratorCClassData.parentMtab))->mtab)
  264.       return;
  265.    ((SOMObject*)((void*)this))->somDefaultInit(0);
  266. }
  267.  
  268. somf_TSetIterator(somf_TSetIterator* fromObj)
  269. {
  270.    if (*(void**)this != 
  271.        ((somParentMtabStructPtr)
  272.         (somf_TSetIteratorCClassData.parentMtab))->mtab)
  273.       return;
  274.    ((SOMObject*)((void*)this))->somDefaultCopyInit(0,((SOMObject*)((void*)fromObj)));
  275. }
  276.  
  277. #ifdef __IBMCPP__
  278. #pragma info(nocnv,nopar)
  279. #endif
  280. somf_TSetIterator(const somf_TSetIterator* fromObj)
  281. {
  282.    if (*(void**)this != 
  283.        ((somParentMtabStructPtr)
  284.         (somf_TSetIteratorCClassData.parentMtab))->mtab)
  285.       return;
  286.    ((SOMObject*)((void*)this))->somDefaultConstCopyInit(0,((SOMObject*)((void*)fromObj)));
  287. }
  288. #ifdef __IBMCPP__
  289. #pragma info(restore)
  290. #endif
  291.  
  292.  
  293. /* method: somfTSetIteratorInit */
  294. somf_TSetIterator*   somfTSetIteratorInit(Environment *ev, 
  295.         somf_TSet* h)
  296. {
  297. /*
  298.  *  Initialize somf_TSetIterator using somf_TSet h.
  299.  */
  300.    return SOM_ResolveD(this,somf_TSetIterator,somf_TSetIterator,somfTSetIteratorInit)
  301.     (this, ev,h);
  302. }
  303.  
  304.  
  305. /*
  306.  * Reintroduce inherited methods
  307.  */
  308.  
  309. /* method: somfNext */
  310. somf_MCollectible*   somfNext(Environment *ev)
  311. {
  312. /*
  313.  *  Retrieve the next object in the collection and return it.  The order that
  314.  *  objects are retrieved is in an order that reflects the "ordered-ness"
  315.  *  of the collection (or the lack of ordering on the collection elements).
  316.  *  If the collection has changed since the last time somfFirst was called,
  317.  *  this method will FAIL.
  318.  */
  319.    return SOM_ResolveD(this,somf_TSetIterator,somf_TIterator,somfNext)
  320.     (this, ev);
  321. }
  322.  
  323.  
  324. /* method: somfFirst */
  325. somf_MCollectible*   somfFirst(Environment *ev)
  326. {
  327. /*
  328.  *  Reset the iterator and return the first element of the collection.  This
  329.  *  resyncs the iterator to the collection if other operations on the
  330.  *  collection caused the iterator to be invalidated.
  331.  */
  332.    return SOM_ResolveD(this,somf_TSetIterator,somf_TIterator,somfFirst)
  333.     (this, ev);
  334. }
  335.  
  336.  
  337. /* method: somfRemove */
  338. void   somfRemove(Environment *ev)
  339. {
  340. /*
  341.  *  Remove the current object, the one just returned by First or Next,
  342.  *  from the Collection.
  343.  */
  344.    SOM_ResolveD(this,somf_TSetIterator,somf_TIterator,somfRemove)
  345.     (this, ev);
  346. }
  347.  
  348.  
  349. /* initializer method: somDefaultInit */
  350. void   somDefaultInit(som3InitCtrl* ctrl)
  351. {
  352. /*
  353.  *  A default initializer for a SOM object. Passing a null ctrl
  354.  *  indicates to the receiver that its class is the class of the
  355.  *  object being initialized, whereby the initializer will determine
  356.  *  an appropriate control structure.
  357.  */
  358.    SOM_ResolveD(this,somf_TSetIterator,SOMObject,somDefaultInit)
  359.     (this,ctrl);
  360. }
  361.  
  362.  
  363. /* method: somDestruct */
  364. void   somDestruct(octet doFree, 
  365.         som3DestructCtrl* ctrl)
  366. {
  367. /*
  368.  *  The default destructor for a SOM object. A nonzero <doFree>
  369.  *  indicates that the object storage should be freed by the
  370.  *  object's class (via somDeallocate) after uninitialization.
  371.  *  As with somDefaultInit, a null ctrl can be passed.
  372.  */
  373.    SOM_ResolveD(this,somf_TSetIterator,SOMObject,somDestruct)
  374.     (this,doFree,ctrl);
  375. }
  376.  
  377.  
  378. /* initializer method: somDefaultCopyInit */
  379. void   somDefaultCopyInit(som3InitCtrl* ctrl, 
  380.         SOMObject* fromObj)
  381. {
  382. /*
  383.  *  A default copy constructor. Use this to make copies of objects for
  384.  *  calling methods with "by-value" argument semantics.
  385.  */
  386.    SOM_ResolveD(this,somf_TSetIterator,SOMObject,somDefaultCopyInit)
  387.     (this,ctrl,fromObj);
  388. }
  389.  
  390.  
  391. /* method: somDefaultAssign */
  392. somf_TSetIterator*  somDefaultAssign(som3AssignCtrl* ctrl, 
  393.         SOMObject* fromObj)
  394. {
  395. /*
  396.  *  A default assignment operator. Use this to "assign" the state of one
  397.  *  object to another.
  398.  */
  399.    return SOM_ResolveD(this,somf_TSetIterator,SOMObject,somDefaultAssign)
  400.     (this,ctrl,fromObj);
  401. }
  402.  
  403.  
  404. /* initializer method: somDefaultConstCopyInit */
  405. void   somDefaultConstCopyInit(som3InitCtrl* ctrl, 
  406.         SOMObject* fromObj)
  407. {
  408. /*
  409.  *  A default copy constructor that uses a const fromObj.
  410.  */
  411.    SOM_ResolveD(this,somf_TSetIterator,SOMObject,somDefaultConstCopyInit)
  412.     (this,ctrl,fromObj);
  413. }
  414.  
  415.  
  416. /* initializer method: somDefaultVCopyInit */
  417. void   somDefaultVCopyInit(som3InitCtrl* ctrl, 
  418.         SOMObject* fromObj)
  419. {
  420. /*
  421.  *  A default copy constructor that uses a volatile fromObj.
  422.  */
  423.    SOM_ResolveD(this,somf_TSetIterator,SOMObject,somDefaultVCopyInit)
  424.     (this,ctrl,fromObj);
  425. }
  426.  
  427.  
  428. /* initializer method: somDefaultConstVCopyInit */
  429. void   somDefaultConstVCopyInit(som3InitCtrl* ctrl, 
  430.         SOMObject* fromObj)
  431. {
  432. /*
  433.  *  A default copy constructor that uses a const volatile fromObj.
  434.  */
  435.    SOM_ResolveD(this,somf_TSetIterator,SOMObject,somDefaultConstVCopyInit)
  436.     (this,ctrl,fromObj);
  437. }
  438.  
  439.  
  440. /* method: somDefaultConstAssign */
  441. somf_TSetIterator*  somDefaultConstAssign(som3AssignCtrl* ctrl, 
  442.         SOMObject* fromObj)
  443. {
  444. /*
  445.  *  A default assignment operator that uses a const fromObj.
  446.  */
  447.    return SOM_ResolveD(this,somf_TSetIterator,SOMObject,somDefaultConstAssign)
  448.     (this,ctrl,fromObj);
  449. }
  450.  
  451.  
  452. /* method: somDefaultVAssign */
  453. somf_TSetIterator*  somDefaultVAssign(som3AssignCtrl* ctrl, 
  454.         SOMObject* fromObj)
  455. {
  456. /*
  457.  *  A default assignment operator that uses a volatile fromObj.
  458.  */
  459.    return SOM_ResolveD(this,somf_TSetIterator,SOMObject,somDefaultVAssign)
  460.     (this,ctrl,fromObj);
  461. }
  462.  
  463.  
  464. /* method: somDefaultConstVAssign */
  465. somf_TSetIterator*  somDefaultConstVAssign(som3AssignCtrl* ctrl, 
  466.         SOMObject* fromObj)
  467. {
  468. /*
  469.  *  A default assignment operator that uses a const volatile fromObj.
  470.  */
  471.    return SOM_ResolveD(this,somf_TSetIterator,SOMObject,somDefaultConstVAssign)
  472.     (this,ctrl,fromObj);
  473. }
  474.  
  475.  
  476. /* method: somInit */
  477. void   somInit()
  478. {
  479. /*
  480.  *  Obsolete but still supported. Override somDefaultInit instead of somInit.
  481.  */
  482.    SOM_ResolveD(this,somf_TSetIterator,SOMObject,somInit)
  483.     (this);
  484. }
  485.  
  486.  
  487. /* method: somFree */
  488. void   somFree()
  489. {
  490. /*
  491.  *  Use as directed by framework implementations.
  492.  */
  493.    SOM_ResolveD(this,somf_TSetIterator,SOMObject,somFree)
  494.     (this);
  495. }
  496.  
  497.  
  498. /* method: somUninit */
  499. void   somUninit()
  500. {
  501. /*
  502.  *  Obsolete but still supported. Override somDestruct instead of somUninit.
  503.  */
  504.    SOM_ResolveD(this,somf_TSetIterator,SOMObject,somUninit)
  505.     (this);
  506. }
  507.  
  508.  
  509. /* method: somGetClass */
  510. SOMClass*   somGetClass()
  511. {
  512. /*
  513.  *  Return the receiver's class.
  514.  */
  515.    return SOM_ResolveD(this,somf_TSetIterator,SOMObject,somGetClass)
  516.     (this);
  517. }
  518.  
  519.  
  520. /* method: somGetClassName */
  521. string   somGetClassName()
  522. {
  523. /*
  524.  *  Return the name of the receiver's class.
  525.  */
  526.    return SOM_ResolveD(this,somf_TSetIterator,SOMObject,somGetClassName)
  527.     (this);
  528. }
  529.  
  530.  
  531. /* method: somGetSize */
  532. long   somGetSize()
  533. {
  534. /*
  535.  *  Return the size of the receiver.
  536.  */
  537.    return SOM_ResolveD(this,somf_TSetIterator,SOMObject,somGetSize)
  538.     (this);
  539. }
  540.  
  541.  
  542. /* method: somIsA */
  543. boolean   somIsA(SOMClass* aClassObj)
  544. {
  545. /*
  546.  *  Returns 1 (true) if the receiver responds to methods
  547.  *  introduced by <aClassObj>, and 0 (false) otherwise.
  548.  */
  549.    return SOM_ResolveD(this,somf_TSetIterator,SOMObject,somIsA)
  550.     (this,aClassObj);
  551. }
  552.  
  553.  
  554. /* method: somIsInstanceOf */
  555. boolean   somIsInstanceOf(SOMClass* aClassObj)
  556. {
  557. /*
  558.  *  Returns 1 (true) if the receiver is an instance of
  559.  *  <aClassObj> and 0 (false) otherwise.
  560.  */
  561.    return SOM_ResolveD(this,somf_TSetIterator,SOMObject,somIsInstanceOf)
  562.     (this,aClassObj);
  563. }
  564.  
  565.  
  566. /* method: somRespondsTo */
  567. boolean   somRespondsTo(somId mId)
  568. {
  569. /*
  570.  *  Returns 1 (true) if the indicated method can be invoked
  571.  *  on the receiver and 0 (false) otherwise.
  572.  */
  573.    return SOM_ResolveD(this,somf_TSetIterator,SOMObject,somRespondsTo)
  574.     (this,mId);
  575. }
  576.  
  577.  
  578. /* va_list method: somDispatch */
  579.  
  580. /*
  581.  *  This method provides a generic, class-specific dispatch mechanism.
  582.  *  It accepts as input <retValue> a pointer to the memory area to be
  583.  *  loaded with the result of dispatching the method indicated by
  584.  *  <methodId> using the arguments in <ap>. <ap> contains the object
  585.  *  on which the method is to be invoked as the first argument.
  586.  */
  587. /* the va_list invocation form */
  588. boolean   somf_TSetIterator_somDispatch(somToken* retValue, 
  589.         somId methodId, 
  590.         va_list ap)
  591. {return SOM_ResolveD(this,somf_TSetIterator,SOMObject,somDispatch)
  592.     (this,retValue,methodId,ap);
  593. }
  594.  
  595. /* the varargs invocation form */
  596. boolean   somDispatch(somToken* retValue, 
  597.         somId methodId, 
  598.         ...)
  599. {
  600. /*
  601.  *  This method provides a generic, class-specific dispatch mechanism.
  602.  *  It accepts as input <retValue> a pointer to the memory area to be
  603.  *  loaded with the result of dispatching the method indicated by
  604.  *  <methodId> using the arguments in <ap>. <ap> contains the object
  605.  *  on which the method is to be invoked as the first argument.
  606.  */
  607.    va_list ap;
  608.    va_start(ap, methodId);
  609.    boolean __somResult = 
  610.       SOM_ResolveD(this,somf_TSetIterator,SOMObject,somDispatch)
  611.     (this,retValue,methodId,ap);
  612.    va_end(ap);
  613.    return __somResult;
  614. }
  615.  
  616.  
  617. /* va_list method: somClassDispatch */
  618.  
  619. /*
  620.  *  Like somDispatch, but method resolution for static methods is done
  621.  *  according to the clsObj instance method table.
  622.  */
  623. /* the va_list invocation form */
  624. boolean   somf_TSetIterator_somClassDispatch(SOMClass* clsObj, 
  625.         somToken* retValue, 
  626.         somId methodId, 
  627.         va_list ap)
  628. {return SOM_ResolveD(this,somf_TSetIterator,SOMObject,somClassDispatch)
  629.     (this,clsObj,retValue,methodId,ap);
  630. }
  631.  
  632. /* the varargs invocation form */
  633. boolean   somClassDispatch(SOMClass* clsObj, 
  634.         somToken* retValue, 
  635.         somId methodId, 
  636.         ...)
  637. {
  638. /*
  639.  *  Like somDispatch, but method resolution for static methods is done
  640.  *  according to the clsObj instance method table.
  641.  */
  642.    va_list ap;
  643.    va_start(ap, methodId);
  644.    boolean __somResult = 
  645.       SOM_ResolveD(this,somf_TSetIterator,SOMObject,somClassDispatch)
  646.     (this,clsObj,retValue,methodId,ap);
  647.    va_end(ap);
  648.    return __somResult;
  649. }
  650.  
  651.  
  652. /* method: somCastObj */
  653. boolean   somCastObj(SOMClass* cls)
  654. {
  655. /*
  656.  *  cast the receiving object to cls (which must be an ancestor of the
  657.  *  objects true class. Returns true on success.
  658.  */
  659.    return SOM_ResolveD(this,somf_TSetIterator,SOMObject,somCastObj)
  660.     (this,cls);
  661. }
  662.  
  663.  
  664. /* method: somResetObj */
  665. boolean   somResetObj()
  666. {
  667. /*
  668.  *  reset an object to its true class. Returns true always.
  669.  */
  670.    return SOM_ResolveD(this,somf_TSetIterator,SOMObject,somResetObj)
  671.     (this);
  672. }
  673.  
  674.  
  675. /* va_list method: somDispatchV */
  676.  
  677. /*
  678.  *  Obsolete. Use somDispatch instead.
  679.  */
  680. /* the va_list invocation form */
  681. void   somf_TSetIterator_somDispatchV(somId methodId, 
  682.         somId descriptor, 
  683.         va_list ap)
  684. {   SOM_ResolveD(this,somf_TSetIterator,SOMObject,somDispatchV)
  685.     (this,methodId,descriptor,ap);
  686. }
  687.  
  688. /* the varargs invocation form */
  689. void   somDispatchV(somId methodId, 
  690.         somId descriptor, 
  691.         ...)
  692. {
  693. /*
  694.  *  Obsolete. Use somDispatch instead.
  695.  */
  696.    va_list ap;
  697.    va_start(ap, descriptor);
  698.    SOM_ResolveD(this,somf_TSetIterator,SOMObject,somDispatchV)
  699.     (this,methodId,descriptor,ap);
  700.    va_end(ap);
  701. }
  702.  
  703.  
  704. /* va_list method: somDispatchL */
  705.  
  706. /*
  707.  *  Obsolete. Use somDispatch instead.
  708.  */
  709. /* the va_list invocation form */
  710. long   somf_TSetIterator_somDispatchL(somId methodId, 
  711.         somId descriptor, 
  712.         va_list ap)
  713. {return SOM_ResolveD(this,somf_TSetIterator,SOMObject,somDispatchL)
  714.     (this,methodId,descriptor,ap);
  715. }
  716.  
  717. /* the varargs invocation form */
  718. long   somDispatchL(somId methodId, 
  719.         somId descriptor, 
  720.         ...)
  721. {
  722. /*
  723.  *  Obsolete. Use somDispatch instead.
  724.  */
  725.    va_list ap;
  726.    va_start(ap, descriptor);
  727.    long __somResult = 
  728.       SOM_ResolveD(this,somf_TSetIterator,SOMObject,somDispatchL)
  729.     (this,methodId,descriptor,ap);
  730.    va_end(ap);
  731.    return __somResult;
  732. }
  733.  
  734.  
  735. /* va_list method: somDispatchA */
  736.  
  737. /*
  738.  *  Obsolete. Use somDispatch instead.
  739.  */
  740. /* the va_list invocation form */
  741. void*   somf_TSetIterator_somDispatchA(somId methodId, 
  742.         somId descriptor, 
  743.         va_list ap)
  744. {return SOM_ResolveD(this,somf_TSetIterator,SOMObject,somDispatchA)
  745.     (this,methodId,descriptor,ap);
  746. }
  747.  
  748. /* the varargs invocation form */
  749. void*   somDispatchA(somId methodId, 
  750.         somId descriptor, 
  751.         ...)
  752. {
  753. /*
  754.  *  Obsolete. Use somDispatch instead.
  755.  */
  756.    va_list ap;
  757.    va_start(ap, descriptor);
  758.    void* __somResult = 
  759.       SOM_ResolveD(this,somf_TSetIterator,SOMObject,somDispatchA)
  760.     (this,methodId,descriptor,ap);
  761.    va_end(ap);
  762.    return __somResult;
  763. }
  764.  
  765.  
  766. /* va_list method: somDispatchD */
  767.  
  768. /*
  769.  *  Obsolete. Use somDispatch instead.
  770.  */
  771. /* the va_list invocation form */
  772. double   somf_TSetIterator_somDispatchD(somId methodId, 
  773.         somId descriptor, 
  774.         va_list ap)
  775. {return SOM_ResolveD(this,somf_TSetIterator,SOMObject,somDispatchD)
  776.     (this,methodId,descriptor,ap);
  777. }
  778.  
  779. /* the varargs invocation form */
  780. double   somDispatchD(somId methodId, 
  781.         somId descriptor, 
  782.         ...)
  783. {
  784. /*
  785.  *  Obsolete. Use somDispatch instead.
  786.  */
  787.    va_list ap;
  788.    va_start(ap, descriptor);
  789.    double __somResult = 
  790.       SOM_ResolveD(this,somf_TSetIterator,SOMObject,somDispatchD)
  791.     (this,methodId,descriptor,ap);
  792.    va_end(ap);
  793.    return __somResult;
  794. }
  795.  
  796.  
  797. /* method: somPrintSelf */
  798. SOMObject*   somPrintSelf()
  799. {
  800. /*
  801.  *  Uses <SOMOutCharRoutine> to write a brief string with identifying
  802.  *  information about this object.  The default implementation just gives
  803.  *  the object's class name and its address in memory.
  804.  *  <self> is returned.
  805.  */
  806.    return SOM_ResolveD(this,somf_TSetIterator,SOMObject,somPrintSelf)
  807.     (this);
  808. }
  809.  
  810.  
  811. /* method: somDumpSelf */
  812. void   somDumpSelf(long level)
  813. {
  814. /*
  815.  *  Uses <SOMOutCharRoutine> to write a detailed description of this object
  816.  *  and its current state.
  817.  * 
  818.  *  <level> indicates the nesting level for describing compound objects
  819.  *  it must be greater than or equal to zero.  All lines in the
  820.  *  description will be preceeded by <2*level> spaces.
  821.  * 
  822.  *  This routine only actually writes the data that concerns the object
  823.  *  as a whole, such as class, and uses <somDumpSelfInt> to describe
  824.  *  the object's current state.  This approach allows readable
  825.  *  descriptions of compound objects to be constructed.
  826.  * 
  827.  *  Generally it is not necessary to override this method, if it is
  828.  *  overriden it generally must be completely replaced.
  829.  */
  830.    SOM_ResolveD(this,somf_TSetIterator,SOMObject,somDumpSelf)
  831.     (this,level);
  832. }
  833.  
  834.  
  835. /* method: somDumpSelfInt */
  836. void   somDumpSelfInt(long level)
  837. {
  838. /*
  839.  *  Uses <SOMOutCharRoutine> to write in the current state of this object.
  840.  *  Generally this method will need to be overridden.  When overriding
  841.  *  it, begin by calling the parent class form of this method and then
  842.  *  write in a description of your class's instance data. This will
  843.  *  result in a description of all the object's instance data going
  844.  *  from its root ancestor class to its specific class.
  845.  */
  846.    SOM_ResolveD(this,somf_TSetIterator,SOMObject,somDumpSelfInt)
  847.     (this,level);
  848. }
  849.  
  850.  
  851.  
  852. };   /* somf_TSetIterator */
  853.  
  854.  
  855.  
  856. #endif       /* SOM_somf_TSetIterator_xh */
  857.