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