home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / opendc12.zip / od124os2.exe / od12ort2.exe / pkg / en_us / iodbasec.odz / iodbcitr.xh < prev    next >
Text File  |  1997-04-02  |  24KB  |  869 lines
  1.  
  2. /*
  3.  * This file was generated by the SOM Compiler.
  4.  * FileName: F:\build\os2\iuo\samples\INCLUDE\iodbcitr.xh.
  5.  * Generated using:
  6.  *     SOM Precompiler somipc: 2.29.1.7
  7.  *     SOM Emitter emitxh: 2.42
  8.  */
  9.  
  10. #ifndef SOM_BCIterator_xh
  11. #define SOM_BCIterator_xh
  12.  
  13. class BCIterator;
  14.  
  15. #define BCIterator_MajorVersion 0
  16. #define BCIterator_MinorVersion 0
  17.  
  18. /* C++ SOM defs */
  19. #include <somcls.xh>
  20. #include <somcm.xh>
  21.  
  22. /* C++ parent defs */
  23. #ifndef SOM_ODEmbeddedFramesIterator_xh
  24. #include <EmbFrItr.xh>
  25. #endif
  26.  
  27. #ifndef BCIterator_API
  28. #define BCIterator_API
  29. /*
  30.  * -- The Class API
  31.  */
  32.  
  33. /*
  34.  * Start of bindings for IDL types
  35.  */
  36.  
  37. class SOMClass;
  38. class SOMObject;
  39. class ODFrame;
  40. class ODFacet;
  41. class ODPlatformCanvas;
  42. class ODObject;
  43. class ODExtension;
  44. class ODEmbeddedFramesIterator;
  45. class ODPart;
  46. class ALinkedList;
  47. class ALink;
  48.  
  49. /*
  50.  * End of bindings for IDL types.
  51.  */
  52.  
  53. /* A procedure to create the BCIterator Class */
  54. SOMEXTERN SOMClass * SOMLINK BCIteratorNewClass(
  55.         integer4 majorVersion,
  56.         integer4 minorVersion);
  57.  
  58. /* The API to the BCIterator class object, and the methods it introduces. */
  59. SOMEXTERN struct BCIteratorClassDataStructure {
  60.     SOMClass *classObject;
  61. } SOMDLINK BCIteratorClassData;
  62. #define _BCIterator BCIteratorClassData.classObject
  63.  
  64. /* The API to parentMtabs for BCIterator, and the instance data it introduces. */
  65. SOMEXTERN struct BCIteratorCClassDataStructure {
  66.     somMethodTabs parentMtab;
  67.     somDToken              instanceDataToken;
  68. } SOMDLINK BCIteratorCClassData;
  69.  
  70. /*
  71.  * -- Typedefs for BCIterator Method Procedures
  72.  */
  73. SOMEXTERN {
  74.  
  75. /*
  76.  * -- Typedefs for Reintroduced Wrapper Methods
  77.  */
  78. typedef void   SOMLINK somTP_BCIterator_InitEmbeddedFramesIterator(BCIterator *somSelf, Environment *ev, 
  79.         ODPart* part);
  80. typedef somTP_BCIterator_InitEmbeddedFramesIterator *somTD_BCIterator_InitEmbeddedFramesIterator;
  81. typedef ODFrame*   SOMLINK somTP_BCIterator_First(BCIterator *somSelf, Environment *ev);
  82. typedef somTP_BCIterator_First *somTD_BCIterator_First;
  83. typedef ODFrame*   SOMLINK somTP_BCIterator_Next(BCIterator *somSelf, Environment *ev);
  84. typedef somTP_BCIterator_Next *somTD_BCIterator_Next;
  85. typedef ODBoolean   SOMLINK somTP_BCIterator_IsNotComplete(BCIterator *somSelf, Environment *ev);
  86. typedef somTP_BCIterator_IsNotComplete *somTD_BCIterator_IsNotComplete;
  87. typedef void   SOMLINK somTP_BCIterator_PartRemoved(BCIterator *somSelf, Environment *ev);
  88. typedef somTP_BCIterator_PartRemoved *somTD_BCIterator_PartRemoved;
  89. typedef ODBoolean   SOMLINK somTP_BCIterator_IsValid(BCIterator *somSelf, Environment *ev);
  90. typedef somTP_BCIterator_IsValid *somTD_BCIterator_IsValid;
  91. typedef void   SOMLINK somTP_BCIterator_CheckValid(BCIterator *somSelf, Environment *ev);
  92. typedef somTP_BCIterator_CheckValid *somTD_BCIterator_CheckValid;
  93. typedef void   SOMLINK somTP_BCIterator_somUninit(BCIterator *somSelf);
  94. typedef somTP_BCIterator_somUninit *somTD_BCIterator_somUninit;
  95. typedef void   SOMLINK somTP_BCIterator_InitObject(BCIterator *somSelf, Environment *ev);
  96. typedef somTP_BCIterator_InitObject *somTD_BCIterator_InitObject;
  97. typedef ODBoolean   SOMLINK somTP_BCIterator_HasExtension(BCIterator *somSelf, Environment *ev, 
  98.         ODType extensionName);
  99. typedef somTP_BCIterator_HasExtension *somTD_BCIterator_HasExtension;
  100. typedef ODExtension*   SOMLINK somTP_BCIterator_AcquireExtension(BCIterator *somSelf, Environment *ev, 
  101.         ODType extensionName);
  102. typedef somTP_BCIterator_AcquireExtension *somTD_BCIterator_AcquireExtension;
  103. typedef void   SOMLINK somTP_BCIterator_ReleaseExtension(BCIterator *somSelf, Environment *ev, 
  104.         ODExtension* extension);
  105. typedef somTP_BCIterator_ReleaseExtension *somTD_BCIterator_ReleaseExtension;
  106. typedef ODSize   SOMLINK somTP_BCIterator_Purge(BCIterator *somSelf, Environment *ev, 
  107.         ODSize size);
  108. typedef somTP_BCIterator_Purge *somTD_BCIterator_Purge;
  109. typedef ODBoolean   SOMLINK somTP_BCIterator_IsEqualTo(BCIterator *somSelf, Environment *ev, 
  110.         ODObject* object);
  111. typedef somTP_BCIterator_IsEqualTo *somTD_BCIterator_IsEqualTo;
  112. typedef void   SOMLINK somTP_BCIterator_SubClassResponsibility(BCIterator *somSelf, Environment *ev);
  113. typedef somTP_BCIterator_SubClassResponsibility *somTD_BCIterator_SubClassResponsibility;
  114. typedef void   SOMLINK somTP_BCIterator_somInit(BCIterator *somSelf);
  115. typedef somTP_BCIterator_somInit *somTD_BCIterator_somInit;
  116. typedef void   SOMLINK somTP_BCIterator_somDefaultInit(BCIterator *somSelf, 
  117.         som3InitCtrl* ctrl);
  118. typedef somTP_BCIterator_somDefaultInit *somTD_BCIterator_somDefaultInit;
  119. typedef void   SOMLINK somTP_BCIterator_somDestruct(BCIterator *somSelf, 
  120.         octet doFree, 
  121.         som3DestructCtrl* ctrl);
  122. typedef somTP_BCIterator_somDestruct *somTD_BCIterator_somDestruct;
  123. typedef void   SOMLINK somTP_BCIterator_somDefaultCopyInit(BCIterator *somSelf, 
  124.         som3InitCtrl* ctrl, 
  125.         SOMObject* fromObj);
  126. typedef somTP_BCIterator_somDefaultCopyInit *somTD_BCIterator_somDefaultCopyInit;
  127. typedef BCIterator*   SOMLINK somTP_BCIterator_somDefaultAssign(BCIterator *somSelf, 
  128.         som3AssignCtrl* ctrl, 
  129.         SOMObject* fromObj);
  130. typedef somTP_BCIterator_somDefaultAssign *somTD_BCIterator_somDefaultAssign;
  131. typedef void   SOMLINK somTP_BCIterator_somDefaultConstCopyInit(BCIterator *somSelf, 
  132.         som3InitCtrl* ctrl, 
  133.         SOMObject* fromObj);
  134. typedef somTP_BCIterator_somDefaultConstCopyInit *somTD_BCIterator_somDefaultConstCopyInit;
  135. typedef void   SOMLINK somTP_BCIterator_somDefaultVCopyInit(BCIterator *somSelf, 
  136.         som3InitCtrl* ctrl, 
  137.         SOMObject* fromObj);
  138. typedef somTP_BCIterator_somDefaultVCopyInit *somTD_BCIterator_somDefaultVCopyInit;
  139. typedef void   SOMLINK somTP_BCIterator_somDefaultConstVCopyInit(BCIterator *somSelf, 
  140.         som3InitCtrl* ctrl, 
  141.         SOMObject* fromObj);
  142. typedef somTP_BCIterator_somDefaultConstVCopyInit *somTD_BCIterator_somDefaultConstVCopyInit;
  143. typedef BCIterator*   SOMLINK somTP_BCIterator_somDefaultConstAssign(BCIterator *somSelf, 
  144.         som3AssignCtrl* ctrl, 
  145.         SOMObject* fromObj);
  146. typedef somTP_BCIterator_somDefaultConstAssign *somTD_BCIterator_somDefaultConstAssign;
  147. typedef BCIterator*   SOMLINK somTP_BCIterator_somDefaultVAssign(BCIterator *somSelf, 
  148.         som3AssignCtrl* ctrl, 
  149.         SOMObject* fromObj);
  150. typedef somTP_BCIterator_somDefaultVAssign *somTD_BCIterator_somDefaultVAssign;
  151. typedef BCIterator*   SOMLINK somTP_BCIterator_somDefaultConstVAssign(BCIterator *somSelf, 
  152.         som3AssignCtrl* ctrl, 
  153.         SOMObject* fromObj);
  154. typedef somTP_BCIterator_somDefaultConstVAssign *somTD_BCIterator_somDefaultConstVAssign;
  155. typedef void   SOMLINK somTP_BCIterator_somFree(BCIterator *somSelf);
  156. typedef somTP_BCIterator_somFree *somTD_BCIterator_somFree;
  157. typedef SOMClass*   SOMLINK somTP_BCIterator_somGetClass(BCIterator *somSelf);
  158. typedef somTP_BCIterator_somGetClass *somTD_BCIterator_somGetClass;
  159. typedef string   SOMLINK somTP_BCIterator_somGetClassName(BCIterator *somSelf);
  160. typedef somTP_BCIterator_somGetClassName *somTD_BCIterator_somGetClassName;
  161. typedef long   SOMLINK somTP_BCIterator_somGetSize(BCIterator *somSelf);
  162. typedef somTP_BCIterator_somGetSize *somTD_BCIterator_somGetSize;
  163. typedef boolean   SOMLINK somTP_BCIterator_somIsA(BCIterator *somSelf, 
  164.         SOMClass* aClassObj);
  165. typedef somTP_BCIterator_somIsA *somTD_BCIterator_somIsA;
  166. typedef boolean   SOMLINK somTP_BCIterator_somIsInstanceOf(BCIterator *somSelf, 
  167.         SOMClass* aClassObj);
  168. typedef somTP_BCIterator_somIsInstanceOf *somTD_BCIterator_somIsInstanceOf;
  169. typedef boolean   SOMLINK somTP_BCIterator_somRespondsTo(BCIterator *somSelf, 
  170.         somId mId);
  171. typedef somTP_BCIterator_somRespondsTo *somTD_BCIterator_somRespondsTo;
  172. typedef boolean   SOMLINK somTP_BCIterator_somDispatch(BCIterator *somSelf, 
  173.         somToken* retValue, 
  174.         somId methodId, 
  175.         va_list ap);
  176. typedef somTP_BCIterator_somDispatch *somTD_BCIterator_somDispatch;
  177. typedef boolean   SOMLINK somTP_BCIterator_somClassDispatch(BCIterator *somSelf, 
  178.         SOMClass* clsObj, 
  179.         somToken* retValue, 
  180.         somId methodId, 
  181.         va_list ap);
  182. typedef somTP_BCIterator_somClassDispatch *somTD_BCIterator_somClassDispatch;
  183. typedef boolean   SOMLINK somTP_BCIterator_somCastObj(BCIterator *somSelf, 
  184.         SOMClass* cls);
  185. typedef somTP_BCIterator_somCastObj *somTD_BCIterator_somCastObj;
  186. typedef boolean   SOMLINK somTP_BCIterator_somResetObj(BCIterator *somSelf);
  187. typedef somTP_BCIterator_somResetObj *somTD_BCIterator_somResetObj;
  188. typedef void   SOMLINK somTP_BCIterator_somDispatchV(BCIterator *somSelf, 
  189.         somId methodId, 
  190.         somId descriptor, 
  191.         va_list ap);
  192. typedef somTP_BCIterator_somDispatchV *somTD_BCIterator_somDispatchV;
  193. typedef long   SOMLINK somTP_BCIterator_somDispatchL(BCIterator *somSelf, 
  194.         somId methodId, 
  195.         somId descriptor, 
  196.         va_list ap);
  197. typedef somTP_BCIterator_somDispatchL *somTD_BCIterator_somDispatchL;
  198. typedef void*   SOMLINK somTP_BCIterator_somDispatchA(BCIterator *somSelf, 
  199.         somId methodId, 
  200.         somId descriptor, 
  201.         va_list ap);
  202. typedef somTP_BCIterator_somDispatchA *somTD_BCIterator_somDispatchA;
  203. typedef double   SOMLINK somTP_BCIterator_somDispatchD(BCIterator *somSelf, 
  204.         somId methodId, 
  205.         somId descriptor, 
  206.         va_list ap);
  207. typedef somTP_BCIterator_somDispatchD *somTD_BCIterator_somDispatchD;
  208. typedef SOMObject*   SOMLINK somTP_BCIterator_somPrintSelf(BCIterator *somSelf);
  209. typedef somTP_BCIterator_somPrintSelf *somTD_BCIterator_somPrintSelf;
  210. typedef void   SOMLINK somTP_BCIterator_somDumpSelf(BCIterator *somSelf, 
  211.         long level);
  212. typedef somTP_BCIterator_somDumpSelf *somTD_BCIterator_somDumpSelf;
  213. typedef void   SOMLINK somTP_BCIterator_somDumpSelfInt(BCIterator *somSelf, 
  214.         long level);
  215. typedef somTP_BCIterator_somDumpSelfInt *somTD_BCIterator_somDumpSelfInt;
  216. }
  217.  
  218. #endif /* BCIterator_API */
  219.  
  220.  
  221. /*
  222.  * -- This emitter treats Method Tokens as Thunks by default.
  223.  * -- Use the sc modifier "nothunks" to change this default
  224.  */
  225. #undef somresolve_
  226. #define somresolve_(obj,mToken) ((somMethodProc*)((void)obj, mToken))
  227.  
  228. /*
  229.  * -- The C++ Wrapper Class for BCIterator
  230.  */
  231. class BCIterator : public ODEmbeddedFramesIterator
  232. {
  233. public:
  234.  
  235. // BCIterator::new creates the class object if necessary, and then uses somNewNoInit
  236. // to allocate memory and create the object. Initialization is in ctors.
  237. void *operator new(size_t)
  238. {
  239.    if (!_BCIterator) BCIteratorNewClass(BCIterator_MajorVersion,BCIterator_MinorVersion);
  240.    return (void*)
  241.       SOM_Resolve(_BCIterator,SOMClass,somNewNoInit)
  242.          ((SOMClass *)((void*)_BCIterator));
  243. }
  244.  
  245. // BCIterator::delete uses somDestruct.
  246. void operator delete(void * obj)
  247. {
  248.    if (obj && *(void**)obj) {
  249.       SOM_Resolve(obj,SOMObject,somFree)
  250.          ((SOMObject*)obj);
  251.    }
  252. }
  253.  
  254. BCIterator& operator=(BCIterator& fromObj)
  255. {
  256.    this->somDefaultAssign(0,(SOMObject*)((void*)&fromObj));
  257.    return *this;
  258. }
  259.  
  260. BCIterator()
  261. {
  262.    if (*(void**)this != 
  263.        ((somParentMtabStructPtr)
  264.         (BCIteratorCClassData.parentMtab))->mtab)
  265.       return;
  266.    ((SOMObject*)((void*)this))->somDefaultInit(0);
  267. }
  268.  
  269. BCIterator(BCIterator* fromObj)
  270. {
  271.    if (*(void**)this != 
  272.        ((somParentMtabStructPtr)
  273.         (BCIteratorCClassData.parentMtab))->mtab)
  274.       return;
  275.    ((SOMObject*)((void*)this))->somDefaultCopyInit(0,((SOMObject*)((void*)fromObj)));
  276. }
  277.  
  278. #ifdef __IBMCPP__
  279. #pragma info(nocnv,nopar)
  280. #endif
  281. BCIterator(const BCIterator* fromObj)
  282. {
  283.    if (*(void**)this != 
  284.        ((somParentMtabStructPtr)
  285.         (BCIteratorCClassData.parentMtab))->mtab)
  286.       return;
  287.    ((SOMObject*)((void*)this))->somDefaultConstCopyInit(0,((SOMObject*)((void*)fromObj)));
  288. }
  289. #ifdef __IBMCPP__
  290. #pragma info(restore)
  291. #endif
  292.  
  293.  
  294. /*
  295.  * Reintroduce inherited methods
  296.  */
  297.  
  298. /* method: InitEmbeddedFramesIterator */
  299. void   InitEmbeddedFramesIterator(Environment *ev, 
  300.         ODPart* part)
  301. {
  302.    SOM_ResolveD(this,BCIterator,ODEmbeddedFramesIterator,InitEmbeddedFramesIterator)
  303.     (this, ev,part);
  304. #ifdef SOMCHKEXCEPT
  305.    if ( ev->_major != NO_EXCEPTION )
  306.       SOMCHKEXCEPT;
  307. #endif
  308. }
  309.  
  310.  
  311. /* method: First */
  312. ODFrame*   First(Environment *ev)
  313. {
  314. #ifdef SOMCHKEXCEPT
  315.    ODFrame* __somResult = 
  316.       SOM_ResolveD(this,BCIterator,ODEmbeddedFramesIterator,First)
  317.     (this, ev);
  318.    if ( ev->_major != NO_EXCEPTION )
  319.       SOMCHKEXCEPT;
  320.    return __somResult;
  321. #else
  322.    return SOM_ResolveD(this,BCIterator,ODEmbeddedFramesIterator,First)
  323.     (this, ev);
  324. #endif
  325. }
  326.  
  327.  
  328. /* method: Next */
  329. ODFrame*   Next(Environment *ev)
  330. {
  331. #ifdef SOMCHKEXCEPT
  332.    ODFrame* __somResult = 
  333.       SOM_ResolveD(this,BCIterator,ODEmbeddedFramesIterator,Next)
  334.     (this, ev);
  335.    if ( ev->_major != NO_EXCEPTION )
  336.       SOMCHKEXCEPT;
  337.    return __somResult;
  338. #else
  339.    return SOM_ResolveD(this,BCIterator,ODEmbeddedFramesIterator,Next)
  340.     (this, ev);
  341. #endif
  342. }
  343.  
  344.  
  345. /* method: IsNotComplete */
  346. ODBoolean   IsNotComplete(Environment *ev)
  347. {
  348. #ifdef SOMCHKEXCEPT
  349.    ODBoolean __somResult = 
  350.       SOM_ResolveD(this,BCIterator,ODEmbeddedFramesIterator,IsNotComplete)
  351.     (this, ev);
  352.    if ( ev->_major != NO_EXCEPTION )
  353.       SOMCHKEXCEPT;
  354.    return __somResult;
  355. #else
  356.    return SOM_ResolveD(this,BCIterator,ODEmbeddedFramesIterator,IsNotComplete)
  357.     (this, ev);
  358. #endif
  359. }
  360.  
  361.  
  362. /* method: PartRemoved */
  363. void   PartRemoved(Environment *ev)
  364. {
  365.    SOM_ResolveD(this,BCIterator,ODEmbeddedFramesIterator,PartRemoved)
  366.     (this, ev);
  367. #ifdef SOMCHKEXCEPT
  368.    if ( ev->_major != NO_EXCEPTION )
  369.       SOMCHKEXCEPT;
  370. #endif
  371. }
  372.  
  373.  
  374. /* method: IsValid */
  375. ODBoolean   IsValid(Environment *ev)
  376. {
  377. #ifdef SOMCHKEXCEPT
  378.    ODBoolean __somResult = 
  379.       SOM_ResolveD(this,BCIterator,ODEmbeddedFramesIterator,IsValid)
  380.     (this, ev);
  381.    if ( ev->_major != NO_EXCEPTION )
  382.       SOMCHKEXCEPT;
  383.    return __somResult;
  384. #else
  385.    return SOM_ResolveD(this,BCIterator,ODEmbeddedFramesIterator,IsValid)
  386.     (this, ev);
  387. #endif
  388. }
  389.  
  390.  
  391. /* method: CheckValid */
  392. void   CheckValid(Environment *ev)
  393. {
  394.    SOM_ResolveD(this,BCIterator,ODEmbeddedFramesIterator,CheckValid)
  395.     (this, ev);
  396. #ifdef SOMCHKEXCEPT
  397.    if ( ev->_major != NO_EXCEPTION )
  398.       SOMCHKEXCEPT;
  399. #endif
  400. }
  401.  
  402.  
  403. /* method: somUninit */
  404. void   somUninit()
  405. {
  406.    SOM_ResolveD(this,BCIterator,SOMObject,somUninit)
  407.     (this);
  408. }
  409.  
  410.  
  411. /* method: InitObject */
  412. void   InitObject(Environment *ev)
  413. {
  414.    SOM_ResolveD(this,BCIterator,ODObject,InitObject)
  415.     (this, ev);
  416. #ifdef SOMCHKEXCEPT
  417.    if ( ev->_major != NO_EXCEPTION )
  418.       SOMCHKEXCEPT;
  419. #endif
  420. }
  421.  
  422.  
  423. /* method: HasExtension */
  424. ODBoolean   HasExtension(Environment *ev, 
  425.         ODType extensionName)
  426. {
  427. #ifdef SOMCHKEXCEPT
  428.    ODBoolean __somResult = 
  429.       SOM_ResolveD(this,BCIterator,ODObject,HasExtension)
  430.     (this, ev,extensionName);
  431.    if ( ev->_major != NO_EXCEPTION )
  432.       SOMCHKEXCEPT;
  433.    return __somResult;
  434. #else
  435.    return SOM_ResolveD(this,BCIterator,ODObject,HasExtension)
  436.     (this, ev,extensionName);
  437. #endif
  438. }
  439.  
  440.  
  441. /* method: AcquireExtension */
  442. ODExtension*   AcquireExtension(Environment *ev, 
  443.         ODType extensionName)
  444. {
  445. #ifdef SOMCHKEXCEPT
  446.    ODExtension* __somResult = 
  447.       SOM_ResolveD(this,BCIterator,ODObject,AcquireExtension)
  448.     (this, ev,extensionName);
  449.    if ( ev->_major != NO_EXCEPTION )
  450.       SOMCHKEXCEPT;
  451.    return __somResult;
  452. #else
  453.    return SOM_ResolveD(this,BCIterator,ODObject,AcquireExtension)
  454.     (this, ev,extensionName);
  455. #endif
  456. }
  457.  
  458.  
  459. /* method: ReleaseExtension */
  460. void   ReleaseExtension(Environment *ev, 
  461.         ODExtension* extension)
  462. {
  463.    SOM_ResolveD(this,BCIterator,ODObject,ReleaseExtension)
  464.     (this, ev,extension);
  465. #ifdef SOMCHKEXCEPT
  466.    if ( ev->_major != NO_EXCEPTION )
  467.       SOMCHKEXCEPT;
  468. #endif
  469. }
  470.  
  471.  
  472. /* method: Purge */
  473. ODSize   Purge(Environment *ev, 
  474.         ODSize size)
  475. {
  476. #ifdef SOMCHKEXCEPT
  477.    ODSize __somResult = 
  478.       SOM_ResolveD(this,BCIterator,ODObject,Purge)
  479.     (this, ev,size);
  480.    if ( ev->_major != NO_EXCEPTION )
  481.       SOMCHKEXCEPT;
  482.    return __somResult;
  483. #else
  484.    return SOM_ResolveD(this,BCIterator,ODObject,Purge)
  485.     (this, ev,size);
  486. #endif
  487. }
  488.  
  489.  
  490. /* method: IsEqualTo */
  491. ODBoolean   IsEqualTo(Environment *ev, 
  492.         ODObject* object)
  493. {
  494. #ifdef SOMCHKEXCEPT
  495.    ODBoolean __somResult = 
  496.       SOM_ResolveD(this,BCIterator,ODObject,IsEqualTo)
  497.     (this, ev,object);
  498.    if ( ev->_major != NO_EXCEPTION )
  499.       SOMCHKEXCEPT;
  500.    return __somResult;
  501. #else
  502.    return SOM_ResolveD(this,BCIterator,ODObject,IsEqualTo)
  503.     (this, ev,object);
  504. #endif
  505. }
  506.  
  507.  
  508. /* method: SubClassResponsibility */
  509. void   SubClassResponsibility(Environment *ev)
  510. {
  511.    SOM_ResolveD(this,BCIterator,ODObject,SubClassResponsibility)
  512.     (this, ev);
  513. #ifdef SOMCHKEXCEPT
  514.    if ( ev->_major != NO_EXCEPTION )
  515.       SOMCHKEXCEPT;
  516. #endif
  517. }
  518.  
  519.  
  520. /* method: somInit */
  521. void   somInit()
  522. {
  523.    SOM_ResolveD(this,BCIterator,SOMObject,somInit)
  524.     (this);
  525. }
  526.  
  527.  
  528. /* initializer method: somDefaultInit */
  529. void   somDefaultInit(som3InitCtrl* ctrl)
  530. {
  531.    SOM_ResolveD(this,BCIterator,SOMObject,somDefaultInit)
  532.     (this,ctrl);
  533. }
  534.  
  535.  
  536. /* method: somDestruct */
  537. void   somDestruct(octet doFree, 
  538.         som3DestructCtrl* ctrl)
  539. {
  540.    SOM_ResolveD(this,BCIterator,SOMObject,somDestruct)
  541.     (this,doFree,ctrl);
  542. }
  543.  
  544.  
  545. /* initializer method: somDefaultCopyInit */
  546. void   somDefaultCopyInit(som3InitCtrl* ctrl, 
  547.         SOMObject* fromObj)
  548. {
  549.    SOM_ResolveD(this,BCIterator,SOMObject,somDefaultCopyInit)
  550.     (this,ctrl,fromObj);
  551. }
  552.  
  553.  
  554. /* method: somDefaultAssign */
  555. BCIterator*  somDefaultAssign(som3AssignCtrl* ctrl, 
  556.         SOMObject* fromObj)
  557. {
  558.    return SOM_ResolveD(this,BCIterator,SOMObject,somDefaultAssign)
  559.     (this,ctrl,fromObj);
  560. }
  561.  
  562.  
  563. /* initializer method: somDefaultConstCopyInit */
  564. void   somDefaultConstCopyInit(som3InitCtrl* ctrl, 
  565.         SOMObject* fromObj)
  566. {
  567.    SOM_ResolveD(this,BCIterator,SOMObject,somDefaultConstCopyInit)
  568.     (this,ctrl,fromObj);
  569. }
  570.  
  571.  
  572. /* initializer method: somDefaultVCopyInit */
  573. void   somDefaultVCopyInit(som3InitCtrl* ctrl, 
  574.         SOMObject* fromObj)
  575. {
  576.    SOM_ResolveD(this,BCIterator,SOMObject,somDefaultVCopyInit)
  577.     (this,ctrl,fromObj);
  578. }
  579.  
  580.  
  581. /* initializer method: somDefaultConstVCopyInit */
  582. void   somDefaultConstVCopyInit(som3InitCtrl* ctrl, 
  583.         SOMObject* fromObj)
  584. {
  585.    SOM_ResolveD(this,BCIterator,SOMObject,somDefaultConstVCopyInit)
  586.     (this,ctrl,fromObj);
  587. }
  588.  
  589.  
  590. /* method: somDefaultConstAssign */
  591. BCIterator*  somDefaultConstAssign(som3AssignCtrl* ctrl, 
  592.         SOMObject* fromObj)
  593. {
  594.    return SOM_ResolveD(this,BCIterator,SOMObject,somDefaultConstAssign)
  595.     (this,ctrl,fromObj);
  596. }
  597.  
  598.  
  599. /* method: somDefaultVAssign */
  600. BCIterator*  somDefaultVAssign(som3AssignCtrl* ctrl, 
  601.         SOMObject* fromObj)
  602. {
  603.    return SOM_ResolveD(this,BCIterator,SOMObject,somDefaultVAssign)
  604.     (this,ctrl,fromObj);
  605. }
  606.  
  607.  
  608. /* method: somDefaultConstVAssign */
  609. BCIterator*  somDefaultConstVAssign(som3AssignCtrl* ctrl, 
  610.         SOMObject* fromObj)
  611. {
  612.    return SOM_ResolveD(this,BCIterator,SOMObject,somDefaultConstVAssign)
  613.     (this,ctrl,fromObj);
  614. }
  615.  
  616.  
  617. /* method: somFree */
  618. void   somFree()
  619. {
  620.    SOM_ResolveD(this,BCIterator,SOMObject,somFree)
  621.     (this);
  622. }
  623.  
  624.  
  625. /* method: somGetClass */
  626. SOMClass*   somGetClass()
  627. {
  628.    return SOM_ResolveD(this,BCIterator,SOMObject,somGetClass)
  629.     (this);
  630. }
  631.  
  632.  
  633. /* method: somGetClassName */
  634. string   somGetClassName()
  635. {
  636.    return SOM_ResolveD(this,BCIterator,SOMObject,somGetClassName)
  637.     (this);
  638. }
  639.  
  640.  
  641. /* method: somGetSize */
  642. long   somGetSize()
  643. {
  644.    return SOM_ResolveD(this,BCIterator,SOMObject,somGetSize)
  645.     (this);
  646. }
  647.  
  648.  
  649. /* method: somIsA */
  650. boolean   somIsA(SOMClass* aClassObj)
  651. {
  652.    return SOM_ResolveD(this,BCIterator,SOMObject,somIsA)
  653.     (this,aClassObj);
  654. }
  655.  
  656.  
  657. /* method: somIsInstanceOf */
  658. boolean   somIsInstanceOf(SOMClass* aClassObj)
  659. {
  660.    return SOM_ResolveD(this,BCIterator,SOMObject,somIsInstanceOf)
  661.     (this,aClassObj);
  662. }
  663.  
  664.  
  665. /* method: somRespondsTo */
  666. boolean   somRespondsTo(somId mId)
  667. {
  668.    return SOM_ResolveD(this,BCIterator,SOMObject,somRespondsTo)
  669.     (this,mId);
  670. }
  671.  
  672.  
  673. /* va_list method: somDispatch */
  674.  
  675. /* the va_list invocation form */
  676. boolean   BCIterator_somDispatch(somToken* retValue, 
  677.         somId methodId, 
  678.         va_list ap)
  679. {return SOM_ResolveD(this,BCIterator,SOMObject,somDispatch)
  680.     (this,retValue,methodId,ap);
  681. }
  682.  
  683. /* the varargs invocation form */
  684. boolean   somDispatch(somToken* retValue, 
  685.         somId methodId, 
  686.         ...)
  687. {
  688.    va_list ap;
  689.    va_start(ap, methodId);
  690.    boolean __somResult = 
  691.       SOM_ResolveD(this,BCIterator,SOMObject,somDispatch)
  692.     (this,retValue,methodId,ap);
  693.    va_end(ap);
  694.    return __somResult;
  695. }
  696.  
  697.  
  698. /* va_list method: somClassDispatch */
  699.  
  700. /* the va_list invocation form */
  701. boolean   BCIterator_somClassDispatch(SOMClass* clsObj, 
  702.         somToken* retValue, 
  703.         somId methodId, 
  704.         va_list ap)
  705. {return SOM_ResolveD(this,BCIterator,SOMObject,somClassDispatch)
  706.     (this,clsObj,retValue,methodId,ap);
  707. }
  708.  
  709. /* the varargs invocation form */
  710. boolean   somClassDispatch(SOMClass* clsObj, 
  711.         somToken* retValue, 
  712.         somId methodId, 
  713.         ...)
  714. {
  715.    va_list ap;
  716.    va_start(ap, methodId);
  717.    boolean __somResult = 
  718.       SOM_ResolveD(this,BCIterator,SOMObject,somClassDispatch)
  719.     (this,clsObj,retValue,methodId,ap);
  720.    va_end(ap);
  721.    return __somResult;
  722. }
  723.  
  724.  
  725. /* method: somCastObj */
  726. boolean   somCastObj(SOMClass* cls)
  727. {
  728.    return SOM_ResolveD(this,BCIterator,SOMObject,somCastObj)
  729.     (this,cls);
  730. }
  731.  
  732.  
  733. /* method: somResetObj */
  734. boolean   somResetObj()
  735. {
  736.    return SOM_ResolveD(this,BCIterator,SOMObject,somResetObj)
  737.     (this);
  738. }
  739.  
  740.  
  741. /* va_list method: somDispatchV */
  742.  
  743. /* the va_list invocation form */
  744. void   BCIterator_somDispatchV(somId methodId, 
  745.         somId descriptor, 
  746.         va_list ap)
  747. {   SOM_ResolveD(this,BCIterator,SOMObject,somDispatchV)
  748.     (this,methodId,descriptor,ap);
  749. }
  750.  
  751. /* the varargs invocation form */
  752. void   somDispatchV(somId methodId, 
  753.         somId descriptor, 
  754.         ...)
  755. {
  756.    va_list ap;
  757.    va_start(ap, descriptor);
  758.    SOM_ResolveD(this,BCIterator,SOMObject,somDispatchV)
  759.     (this,methodId,descriptor,ap);
  760.    va_end(ap);
  761. }
  762.  
  763.  
  764. /* va_list method: somDispatchL */
  765.  
  766. /* the va_list invocation form */
  767. long   BCIterator_somDispatchL(somId methodId, 
  768.         somId descriptor, 
  769.         va_list ap)
  770. {return SOM_ResolveD(this,BCIterator,SOMObject,somDispatchL)
  771.     (this,methodId,descriptor,ap);
  772. }
  773.  
  774. /* the varargs invocation form */
  775. long   somDispatchL(somId methodId, 
  776.         somId descriptor, 
  777.         ...)
  778. {
  779.    va_list ap;
  780.    va_start(ap, descriptor);
  781.    long __somResult = 
  782.       SOM_ResolveD(this,BCIterator,SOMObject,somDispatchL)
  783.     (this,methodId,descriptor,ap);
  784.    va_end(ap);
  785.    return __somResult;
  786. }
  787.  
  788.  
  789. /* va_list method: somDispatchA */
  790.  
  791. /* the va_list invocation form */
  792. void*   BCIterator_somDispatchA(somId methodId, 
  793.         somId descriptor, 
  794.         va_list ap)
  795. {return SOM_ResolveD(this,BCIterator,SOMObject,somDispatchA)
  796.     (this,methodId,descriptor,ap);
  797. }
  798.  
  799. /* the varargs invocation form */
  800. void*   somDispatchA(somId methodId, 
  801.         somId descriptor, 
  802.         ...)
  803. {
  804.    va_list ap;
  805.    va_start(ap, descriptor);
  806.    void* __somResult = 
  807.       SOM_ResolveD(this,BCIterator,SOMObject,somDispatchA)
  808.     (this,methodId,descriptor,ap);
  809.    va_end(ap);
  810.    return __somResult;
  811. }
  812.  
  813.  
  814. /* va_list method: somDispatchD */
  815.  
  816. /* the va_list invocation form */
  817. double   BCIterator_somDispatchD(somId methodId, 
  818.         somId descriptor, 
  819.         va_list ap)
  820. {return SOM_ResolveD(this,BCIterator,SOMObject,somDispatchD)
  821.     (this,methodId,descriptor,ap);
  822. }
  823.  
  824. /* the varargs invocation form */
  825. double   somDispatchD(somId methodId, 
  826.         somId descriptor, 
  827.         ...)
  828. {
  829.    va_list ap;
  830.    va_start(ap, descriptor);
  831.    double __somResult = 
  832.       SOM_ResolveD(this,BCIterator,SOMObject,somDispatchD)
  833.     (this,methodId,descriptor,ap);
  834.    va_end(ap);
  835.    return __somResult;
  836. }
  837.  
  838.  
  839. /* method: somPrintSelf */
  840. SOMObject*   somPrintSelf()
  841. {
  842.    return SOM_ResolveD(this,BCIterator,SOMObject,somPrintSelf)
  843.     (this);
  844. }
  845.  
  846.  
  847. /* method: somDumpSelf */
  848. void   somDumpSelf(long level)
  849. {
  850.    SOM_ResolveD(this,BCIterator,SOMObject,somDumpSelf)
  851.     (this,level);
  852. }
  853.  
  854.  
  855. /* method: somDumpSelfInt */
  856. void   somDumpSelfInt(long level)
  857. {
  858.    SOM_ResolveD(this,BCIterator,SOMObject,somDumpSelfInt)
  859.     (this,level);
  860. }
  861.  
  862.  
  863.  
  864. };   /* BCIterator */
  865.  
  866.  
  867.  
  868. #endif       /* SOM_BCIterator_xh */
  869.