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