home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / tolkit45.zip / os2tk45 / som / include / tdeqitr.xh < prev    next >
Text File  |  1999-02-22  |  27KB  |  866 lines
  1.  
  2. /*
  3.  * This file was generated by the SOM Compiler.
  4.  * FileName: tdeqitr.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_TDequeIterator
  25.  * 
  26.  * DESCRIPTION: An iterator for TDeque that will iterate over all of
  27.  *              the objects in a deque.
  28.  * 
  29.  */
  30.  
  31.  
  32. #ifndef SOM_somf_TDequeIterator_xh
  33. #define SOM_somf_TDequeIterator_xh
  34.  
  35. class somf_TDequeIterator;
  36.  
  37. #define somf_TDequeIterator_MajorVersion 2
  38. #define somf_TDequeIterator_MinorVersion 1
  39.  
  40. /*
  41.  * Passthru lines: File: "C.xh", "before"
  42.  */
  43.  
  44. #include <tdeq.xh>
  45.  
  46. /* C++ SOM defs */
  47. #include <somcls.xh>
  48. #include <somcm.xh>
  49.  
  50. /* C++ parent defs */
  51. #ifndef SOM_somf_TSequenceIterator_xh
  52. #include <tseqitr.xh>
  53. #endif
  54.  
  55. #ifndef somf_TDequeIterator_API
  56. #define somf_TDequeIterator_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. class somf_TDeque;
  69. class somf_TDequeLinkable;
  70.  
  71. /*
  72.  * End of bindings for IDL types.
  73.  */
  74.  
  75. /* A procedure to create the somf_TDequeIterator Class */
  76. SOMEXTERN SOMClass * SOMLINK somf_TDequeIteratorNewClass(
  77.         integer4 majorVersion,
  78.         integer4 minorVersion);
  79.  
  80. /* The API to the somf_TDequeIterator class object, and the methods it introduces. */
  81. SOMEXTERN struct somf_TDequeIteratorClassDataStructure {
  82.     SOMClass *classObject;
  83.     somMToken somfTDequeIteratorInit;
  84. } SOMDLINK somf_TDequeIteratorClassData;
  85. #define _somf_TDequeIterator somf_TDequeIteratorClassData.classObject
  86.  
  87. /* The API to parentMtabs for somf_TDequeIterator, and the instance data it introduces. */
  88. SOMEXTERN struct somf_TDequeIteratorCClassDataStructure {
  89.     somMethodTabs parentMtab;
  90.     somDToken              instanceDataToken;
  91. } SOMDLINK somf_TDequeIteratorCClassData;
  92.  
  93. /*
  94.  * -- Typedefs for somf_TDequeIterator Method Procedures
  95.  */
  96. SOMEXTERN {
  97. typedef somf_TDequeIterator*   SOMLINK somTP_somf_TDequeIterator_somfTDequeIteratorInit(somf_TDequeIterator *somSelf, Environment *ev, 
  98.         somf_TDeque* h);
  99. typedef somTP_somf_TDequeIterator_somfTDequeIteratorInit *somTD_somf_TDequeIterator_somfTDequeIteratorInit;
  100.  
  101. /*
  102.  * -- Typedefs for Reintroduced Wrapper Methods
  103.  */
  104. typedef somf_MCollectible*   SOMLINK somTP_somf_TDequeIterator_somfLast(somf_TDequeIterator *somSelf, Environment *ev);
  105. typedef somTP_somf_TDequeIterator_somfLast *somTD_somf_TDequeIterator_somfLast;
  106. typedef somf_MCollectible*   SOMLINK somTP_somf_TDequeIterator_somfPrevious(somf_TDequeIterator *somSelf, Environment *ev);
  107. typedef somTP_somf_TDequeIterator_somfPrevious *somTD_somf_TDequeIterator_somfPrevious;
  108. typedef somf_MCollectible*   SOMLINK somTP_somf_TDequeIterator_somfFirst(somf_TDequeIterator *somSelf, Environment *ev);
  109. typedef somTP_somf_TDequeIterator_somfFirst *somTD_somf_TDequeIterator_somfFirst;
  110. typedef somf_MCollectible*   SOMLINK somTP_somf_TDequeIterator_somfNext(somf_TDequeIterator *somSelf, Environment *ev);
  111. typedef somTP_somf_TDequeIterator_somfNext *somTD_somf_TDequeIterator_somfNext;
  112. typedef void   SOMLINK somTP_somf_TDequeIterator_somfRemove(somf_TDequeIterator *somSelf, Environment *ev);
  113. typedef somTP_somf_TDequeIterator_somfRemove *somTD_somf_TDequeIterator_somfRemove;
  114. typedef void   SOMLINK somTP_somf_TDequeIterator_somDefaultInit(somf_TDequeIterator *somSelf, 
  115.         som3InitCtrl* ctrl);
  116. typedef somTP_somf_TDequeIterator_somDefaultInit *somTD_somf_TDequeIterator_somDefaultInit;
  117. typedef void   SOMLINK somTP_somf_TDequeIterator_somDestruct(somf_TDequeIterator *somSelf, 
  118.         octet doFree, 
  119.         som3DestructCtrl* ctrl);
  120. typedef somTP_somf_TDequeIterator_somDestruct *somTD_somf_TDequeIterator_somDestruct;
  121. typedef void   SOMLINK somTP_somf_TDequeIterator_somDefaultCopyInit(somf_TDequeIterator *somSelf, 
  122.         som3InitCtrl* ctrl, 
  123.         SOMObject* fromObj);
  124. typedef somTP_somf_TDequeIterator_somDefaultCopyInit *somTD_somf_TDequeIterator_somDefaultCopyInit;
  125. typedef somf_TDequeIterator*   SOMLINK somTP_somf_TDequeIterator_somDefaultAssign(somf_TDequeIterator *somSelf, 
  126.         som3AssignCtrl* ctrl, 
  127.         SOMObject* fromObj);
  128. typedef somTP_somf_TDequeIterator_somDefaultAssign *somTD_somf_TDequeIterator_somDefaultAssign;
  129. typedef void   SOMLINK somTP_somf_TDequeIterator_somDefaultConstCopyInit(somf_TDequeIterator *somSelf, 
  130.         som3InitCtrl* ctrl, 
  131.         SOMObject* fromObj);
  132. typedef somTP_somf_TDequeIterator_somDefaultConstCopyInit *somTD_somf_TDequeIterator_somDefaultConstCopyInit;
  133. typedef void   SOMLINK somTP_somf_TDequeIterator_somDefaultVCopyInit(somf_TDequeIterator *somSelf, 
  134.         som3InitCtrl* ctrl, 
  135.         SOMObject* fromObj);
  136. typedef somTP_somf_TDequeIterator_somDefaultVCopyInit *somTD_somf_TDequeIterator_somDefaultVCopyInit;
  137. typedef void   SOMLINK somTP_somf_TDequeIterator_somDefaultConstVCopyInit(somf_TDequeIterator *somSelf, 
  138.         som3InitCtrl* ctrl, 
  139.         SOMObject* fromObj);
  140. typedef somTP_somf_TDequeIterator_somDefaultConstVCopyInit *somTD_somf_TDequeIterator_somDefaultConstVCopyInit;
  141. typedef somf_TDequeIterator*   SOMLINK somTP_somf_TDequeIterator_somDefaultConstAssign(somf_TDequeIterator *somSelf, 
  142.         som3AssignCtrl* ctrl, 
  143.         SOMObject* fromObj);
  144. typedef somTP_somf_TDequeIterator_somDefaultConstAssign *somTD_somf_TDequeIterator_somDefaultConstAssign;
  145. typedef somf_TDequeIterator*   SOMLINK somTP_somf_TDequeIterator_somDefaultVAssign(somf_TDequeIterator *somSelf, 
  146.         som3AssignCtrl* ctrl, 
  147.         SOMObject* fromObj);
  148. typedef somTP_somf_TDequeIterator_somDefaultVAssign *somTD_somf_TDequeIterator_somDefaultVAssign;
  149. typedef somf_TDequeIterator*   SOMLINK somTP_somf_TDequeIterator_somDefaultConstVAssign(somf_TDequeIterator *somSelf, 
  150.         som3AssignCtrl* ctrl, 
  151.         SOMObject* fromObj);
  152. typedef somTP_somf_TDequeIterator_somDefaultConstVAssign *somTD_somf_TDequeIterator_somDefaultConstVAssign;
  153. typedef void   SOMLINK somTP_somf_TDequeIterator_somInit(somf_TDequeIterator *somSelf);
  154. typedef somTP_somf_TDequeIterator_somInit *somTD_somf_TDequeIterator_somInit;
  155. typedef void   SOMLINK somTP_somf_TDequeIterator_somFree(somf_TDequeIterator *somSelf);
  156. typedef somTP_somf_TDequeIterator_somFree *somTD_somf_TDequeIterator_somFree;
  157. typedef void   SOMLINK somTP_somf_TDequeIterator_somUninit(somf_TDequeIterator *somSelf);
  158. typedef somTP_somf_TDequeIterator_somUninit *somTD_somf_TDequeIterator_somUninit;
  159. typedef SOMClass*   SOMLINK somTP_somf_TDequeIterator_somGetClass(somf_TDequeIterator *somSelf);
  160. typedef somTP_somf_TDequeIterator_somGetClass *somTD_somf_TDequeIterator_somGetClass;
  161. typedef string   SOMLINK somTP_somf_TDequeIterator_somGetClassName(somf_TDequeIterator *somSelf);
  162. typedef somTP_somf_TDequeIterator_somGetClassName *somTD_somf_TDequeIterator_somGetClassName;
  163. typedef long   SOMLINK somTP_somf_TDequeIterator_somGetSize(somf_TDequeIterator *somSelf);
  164. typedef somTP_somf_TDequeIterator_somGetSize *somTD_somf_TDequeIterator_somGetSize;
  165. typedef boolean   SOMLINK somTP_somf_TDequeIterator_somIsA(somf_TDequeIterator *somSelf, 
  166.         SOMClass* aClassObj);
  167. typedef somTP_somf_TDequeIterator_somIsA *somTD_somf_TDequeIterator_somIsA;
  168. typedef boolean   SOMLINK somTP_somf_TDequeIterator_somIsInstanceOf(somf_TDequeIterator *somSelf, 
  169.         SOMClass* aClassObj);
  170. typedef somTP_somf_TDequeIterator_somIsInstanceOf *somTD_somf_TDequeIterator_somIsInstanceOf;
  171. typedef boolean   SOMLINK somTP_somf_TDequeIterator_somRespondsTo(somf_TDequeIterator *somSelf, 
  172.         somId mId);
  173. typedef somTP_somf_TDequeIterator_somRespondsTo *somTD_somf_TDequeIterator_somRespondsTo;
  174. typedef boolean   SOMLINK somTP_somf_TDequeIterator_somDispatch(somf_TDequeIterator *somSelf, 
  175.         somToken* retValue, 
  176.         somId methodId, 
  177.         va_list ap);
  178. typedef somTP_somf_TDequeIterator_somDispatch *somTD_somf_TDequeIterator_somDispatch;
  179. typedef boolean   SOMLINK somTP_somf_TDequeIterator_somClassDispatch(somf_TDequeIterator *somSelf, 
  180.         SOMClass* clsObj, 
  181.         somToken* retValue, 
  182.         somId methodId, 
  183.         va_list ap);
  184. typedef somTP_somf_TDequeIterator_somClassDispatch *somTD_somf_TDequeIterator_somClassDispatch;
  185. typedef boolean   SOMLINK somTP_somf_TDequeIterator_somCastObj(somf_TDequeIterator *somSelf, 
  186.         SOMClass* cls);
  187. typedef somTP_somf_TDequeIterator_somCastObj *somTD_somf_TDequeIterator_somCastObj;
  188. typedef boolean   SOMLINK somTP_somf_TDequeIterator_somResetObj(somf_TDequeIterator *somSelf);
  189. typedef somTP_somf_TDequeIterator_somResetObj *somTD_somf_TDequeIterator_somResetObj;
  190. typedef void   SOMLINK somTP_somf_TDequeIterator_somDispatchV(somf_TDequeIterator *somSelf, 
  191.         somId methodId, 
  192.         somId descriptor, 
  193.         va_list ap);
  194. typedef somTP_somf_TDequeIterator_somDispatchV *somTD_somf_TDequeIterator_somDispatchV;
  195. typedef long   SOMLINK somTP_somf_TDequeIterator_somDispatchL(somf_TDequeIterator *somSelf, 
  196.         somId methodId, 
  197.         somId descriptor, 
  198.         va_list ap);
  199. typedef somTP_somf_TDequeIterator_somDispatchL *somTD_somf_TDequeIterator_somDispatchL;
  200. typedef void*   SOMLINK somTP_somf_TDequeIterator_somDispatchA(somf_TDequeIterator *somSelf, 
  201.         somId methodId, 
  202.         somId descriptor, 
  203.         va_list ap);
  204. typedef somTP_somf_TDequeIterator_somDispatchA *somTD_somf_TDequeIterator_somDispatchA;
  205. typedef double   SOMLINK somTP_somf_TDequeIterator_somDispatchD(somf_TDequeIterator *somSelf, 
  206.         somId methodId, 
  207.         somId descriptor, 
  208.         va_list ap);
  209. typedef somTP_somf_TDequeIterator_somDispatchD *somTD_somf_TDequeIterator_somDispatchD;
  210. typedef SOMObject*   SOMLINK somTP_somf_TDequeIterator_somPrintSelf(somf_TDequeIterator *somSelf);
  211. typedef somTP_somf_TDequeIterator_somPrintSelf *somTD_somf_TDequeIterator_somPrintSelf;
  212. typedef void   SOMLINK somTP_somf_TDequeIterator_somDumpSelf(somf_TDequeIterator *somSelf, 
  213.         long level);
  214. typedef somTP_somf_TDequeIterator_somDumpSelf *somTD_somf_TDequeIterator_somDumpSelf;
  215. typedef void   SOMLINK somTP_somf_TDequeIterator_somDumpSelfInt(somf_TDequeIterator *somSelf, 
  216.         long level);
  217. typedef somTP_somf_TDequeIterator_somDumpSelfInt *somTD_somf_TDequeIterator_somDumpSelfInt;
  218. }
  219.  
  220. #endif /* somf_TDequeIterator_API */
  221.  
  222.  
  223. /*
  224.  * -- This emitter treats Method Tokens as Thunks by default.
  225.  * -- Use the sc modifier "nothunks" to change this default
  226.  */
  227. #undef somresolve_
  228. #define somresolve_(obj,mToken) ((somMethodProc*)((void)obj, mToken))
  229.  
  230. /*
  231.  * -- The C++ Wrapper Class for somf_TDequeIterator
  232.  */
  233. class somf_TDequeIterator : public somf_TSequenceIterator
  234. {
  235. public:
  236.  
  237. // somf_TDequeIterator::new creates the class object if necessary, and then uses somNewNoInit
  238. // to allocate memory and create the object. Initialization is in ctors.
  239. void *operator new(size_t)
  240. {
  241.    if (!_somf_TDequeIterator) somf_TDequeIteratorNewClass(somf_TDequeIterator_MajorVersion,somf_TDequeIterator_MinorVersion);
  242.    return (void*)
  243.       SOM_Resolve(_somf_TDequeIterator,SOMClass,somNewNoInit)
  244.          ((SOMClass *)((void*)_somf_TDequeIterator));
  245. }
  246.  
  247. // somf_TDequeIterator::delete uses somDestruct.
  248. void operator delete(void * obj)
  249. {
  250.    if (obj && *(void**)obj) {
  251.       SOM_Resolve(obj,SOMObject,somFree)
  252.          ((SOMObject*)obj);
  253.    }
  254. }
  255.  
  256. somf_TDequeIterator& operator=(somf_TDequeIterator& fromObj)
  257. {
  258.    this->somDefaultAssign(0,(SOMObject*)((void*)&fromObj));
  259.    return *this;
  260. }
  261.  
  262. somf_TDequeIterator()
  263. {
  264.    if (*(void**)this != 
  265.        ((somParentMtabStructPtr)
  266.         (somf_TDequeIteratorCClassData.parentMtab))->mtab)
  267.       return;
  268.    ((SOMObject*)((void*)this))->somDefaultInit(0);
  269. }
  270.  
  271. somf_TDequeIterator(somf_TDequeIterator* fromObj)
  272. {
  273.    if (*(void**)this != 
  274.        ((somParentMtabStructPtr)
  275.         (somf_TDequeIteratorCClassData.parentMtab))->mtab)
  276.       return;
  277.    ((SOMObject*)((void*)this))->somDefaultCopyInit(0,((SOMObject*)((void*)fromObj)));
  278. }
  279.  
  280. #ifdef __IBMCPP__
  281. #pragma info(nocnv,nopar)
  282. #endif
  283. somf_TDequeIterator(const somf_TDequeIterator* fromObj)
  284. {
  285.    if (*(void**)this != 
  286.        ((somParentMtabStructPtr)
  287.         (somf_TDequeIteratorCClassData.parentMtab))->mtab)
  288.       return;
  289.    ((SOMObject*)((void*)this))->somDefaultConstCopyInit(0,((SOMObject*)((void*)fromObj)));
  290. }
  291. #ifdef __IBMCPP__
  292. #pragma info(restore)
  293. #endif
  294.  
  295.  
  296. /* method: somfTDequeIteratorInit */
  297. somf_TDequeIterator*   somfTDequeIteratorInit(Environment *ev, 
  298.         somf_TDeque* h)
  299. {
  300. /*
  301.  *  Initializes the new deque iterator.
  302.  */
  303.    return SOM_ResolveD(this,somf_TDequeIterator,somf_TDequeIterator,somfTDequeIteratorInit)
  304.     (this, ev,h);
  305. }
  306.  
  307.  
  308. /*
  309.  * Reintroduce inherited methods
  310.  */
  311.  
  312. /* method: somfLast */
  313. somf_MCollectible*   somfLast(Environment *ev)
  314. {
  315. /*
  316.  *  Determine the last object in the TSequence.
  317.  */
  318.    return SOM_ResolveD(this,somf_TDequeIterator,somf_TSequenceIterator,somfLast)
  319.     (this, ev);
  320. }
  321.  
  322.  
  323. /* method: somfPrevious */
  324. somf_MCollectible*   somfPrevious(Environment *ev)
  325. {
  326. /*
  327.  *  Determine the previous object in the TSequence.
  328.  */
  329.    return SOM_ResolveD(this,somf_TDequeIterator,somf_TSequenceIterator,somfPrevious)
  330.     (this, ev);
  331. }
  332.  
  333.  
  334. /* method: somfFirst */
  335. somf_MCollectible*   somfFirst(Environment *ev)
  336. {
  337.    return SOM_ResolveD(this,somf_TDequeIterator,somf_TIterator,somfFirst)
  338.     (this, ev);
  339. }
  340.  
  341.  
  342. /* method: somfNext */
  343. somf_MCollectible*   somfNext(Environment *ev)
  344. {
  345.    return SOM_ResolveD(this,somf_TDequeIterator,somf_TIterator,somfNext)
  346.     (this, ev);
  347. }
  348.  
  349.  
  350. /* method: somfRemove */
  351. void   somfRemove(Environment *ev)
  352. {
  353.    SOM_ResolveD(this,somf_TDequeIterator,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_TDequeIterator,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_TDequeIterator,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_TDequeIterator,SOMObject,somDefaultCopyInit)
  396.     (this,ctrl,fromObj);
  397. }
  398.  
  399.  
  400. /* method: somDefaultAssign */
  401. somf_TDequeIterator*  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_TDequeIterator,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_TDequeIterator,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_TDequeIterator,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_TDequeIterator,SOMObject,somDefaultConstVCopyInit)
  445.     (this,ctrl,fromObj);
  446. }
  447.  
  448.  
  449. /* method: somDefaultConstAssign */
  450. somf_TDequeIterator*  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_TDequeIterator,SOMObject,somDefaultConstAssign)
  457.     (this,ctrl,fromObj);
  458. }
  459.  
  460.  
  461. /* method: somDefaultVAssign */
  462. somf_TDequeIterator*  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_TDequeIterator,SOMObject,somDefaultVAssign)
  469.     (this,ctrl,fromObj);
  470. }
  471.  
  472.  
  473. /* method: somDefaultConstVAssign */
  474. somf_TDequeIterator*  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_TDequeIterator,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_TDequeIterator,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_TDequeIterator,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_TDequeIterator,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_TDequeIterator,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_TDequeIterator,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_TDequeIterator,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_TDequeIterator,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_TDequeIterator,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_TDequeIterator,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_TDequeIterator_somDispatch(somToken* retValue, 
  598.         somId methodId, 
  599.         va_list ap)
  600. {return SOM_ResolveD(this,somf_TDequeIterator,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_TDequeIterator,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_TDequeIterator_somClassDispatch(SOMClass* clsObj, 
  634.         somToken* retValue, 
  635.         somId methodId, 
  636.         va_list ap)
  637. {return SOM_ResolveD(this,somf_TDequeIterator,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_TDequeIterator,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_TDequeIterator,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_TDequeIterator,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_TDequeIterator_somDispatchV(somId methodId, 
  691.         somId descriptor, 
  692.         va_list ap)
  693. {   SOM_ResolveD(this,somf_TDequeIterator,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_TDequeIterator,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_TDequeIterator_somDispatchL(somId methodId, 
  720.         somId descriptor, 
  721.         va_list ap)
  722. {return SOM_ResolveD(this,somf_TDequeIterator,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_TDequeIterator,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_TDequeIterator_somDispatchA(somId methodId, 
  751.         somId descriptor, 
  752.         va_list ap)
  753. {return SOM_ResolveD(this,somf_TDequeIterator,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_TDequeIterator,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_TDequeIterator_somDispatchD(somId methodId, 
  782.         somId descriptor, 
  783.         va_list ap)
  784. {return SOM_ResolveD(this,somf_TDequeIterator,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_TDequeIterator,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_TDequeIterator,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_TDequeIterator,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_TDequeIterator,SOMObject,somDumpSelfInt)
  856.     (this,level);
  857. }
  858.  
  859.  
  860.  
  861. };   /* somf_TDequeIterator */
  862.  
  863.  
  864.  
  865. #endif       /* SOM_somf_TDequeIterator_xh */
  866.