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