home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / warptlk3.zip / TOOLKIT / SOM / INCLUDE / BOA.XH < prev    next >
Text File  |  1995-08-30  |  18KB  |  749 lines
  1.  
  2. /*
  3.  * This file was generated by the SOM Compiler.
  4.  * FileName: boa.xh.
  5.  * Generated using:
  6.  *     SOM Precompiler somipc: 2.29.1.2
  7.  *     SOM Emitter emitxh: 2.41
  8.  */
  9.  
  10. /*
  11.  * 
  12.  *    COMPONENT_NAME: somd
  13.  * 
  14.  *    ORIGINS: 27
  15.  * 
  16.  * 
  17.  *    10H9767, 10H9769  (C) COPYRIGHT International Business Machines Corp. 1992,1994
  18.  *    All Rights Reserved
  19.  *    Licensed Materials - Property of IBM
  20.  *    US Government Users Restricted Rights - Use, duplication or
  21.  *    disclosure restricted by GSA ADP Schedule Contract with IBM Corp.
  22.  * 
  23.  *    IDL interface spec for CORBA Basic Object Adapter.
  24.  * 
  25.  *    This is an abstract class which defines the CORBA-defined interface
  26.  *    for a Basic Object Adapter.
  27.  * 
  28.  *    The SOM Object Adapter interface is derived from this one.
  29.  *    SOMOA provides the actual implementation in DSOM.
  30.  */
  31.  
  32.  
  33. #ifndef SOM_BOA_xh
  34. #define SOM_BOA_xh
  35.  
  36. class BOA;
  37.  
  38. #define BOA_MajorVersion 2
  39. #define BOA_MinorVersion 1
  40.  
  41. /* C++ SOM defs */
  42. #include <somcls.xh>
  43. #include <somcm.xh>
  44.  
  45. /* C++ parent defs */
  46. #ifndef SOM_SOMObject_xh
  47. #include <somobj.xh>
  48. #endif
  49.  
  50. /*
  51.  * C++ metaclass def
  52.  */
  53. #include <snglicls.xh>
  54.  
  55. #ifndef BOA_API
  56. #define BOA_API
  57. /*
  58.  * -- The Class API
  59.  */
  60.  
  61. /*
  62.  * Start of user-defined types:
  63.  */
  64. class SOMClass;
  65. class SOMObject;
  66. class Container;
  67. class SOMDObject;
  68. class Principal;
  69. class ImplementationDef;
  70. class InterfaceDef;
  71. class Context;
  72.  
  73. /*
  74.  * End of user-defined types.
  75.  */
  76.  
  77. /* A procedure to create the BOA Class */
  78. class SOMMSingleInstance;
  79. SOMEXTERN SOMMSingleInstance * SOMLINK BOANewClass(
  80.         integer4 majorVersion,
  81.         integer4 minorVersion);
  82.  
  83. /* The API to the BOA class object, and the methods it introduces. */
  84. SOMEXTERN struct BOAClassDataStructure {
  85.     SOMMSingleInstance *classObject;
  86.     somMToken create;
  87.     somMToken dispose;
  88.     somMToken get_id;
  89.     somMToken change_implementation;
  90.     somMToken get_principal;
  91.     somMToken set_exception;
  92.     somMToken impl_is_ready;
  93.     somMToken deactivate_impl;
  94.     somMToken obj_is_ready;
  95.     somMToken deactivate_obj;
  96.     somMToken activate_impl;
  97.     somMToken activate_obj;
  98. } SOMDLINK BOAClassData;
  99. #define _BOA BOAClassData.classObject
  100.  
  101. /* The API to parentMtabs for BOA, and the instance data it introduces. */
  102. SOMEXTERN struct BOACClassDataStructure {
  103.     somMethodTabs parentMtab;
  104.     somDToken              instanceDataToken;
  105. } SOMDLINK BOACClassData;
  106.  
  107. /*
  108.  * -- Typedefs for BOA Method Procedures
  109.  */
  110. SOMEXTERN {
  111. typedef SOMDObject*   (SOMLINK * somTD_BOA_create)(BOA *somSelf, Environment *ev,
  112.         ReferenceData* id,
  113.         InterfaceDef* intf,
  114.         ImplementationDef* impl);
  115. typedef void   (SOMLINK * somTD_BOA_dispose)(BOA *somSelf, Environment *ev,
  116.         SOMDObject* obj);
  117. typedef ReferenceData   (SOMLINK * somTD_BOA_get_id)(BOA *somSelf, Environment *ev,
  118.         SOMDObject* obj);
  119. typedef Principal*   (SOMLINK * somTD_BOA_get_principal)(BOA *somSelf, Environment *ev,
  120.         SOMDObject* obj,
  121.         Environment* req_ev);
  122. typedef void   (SOMLINK * somTD_BOA_set_exception)(BOA *somSelf, Environment *ev,
  123.         exception_type major,
  124.         string userid,
  125.         void* param);
  126. typedef void   (SOMLINK * somTD_BOA_impl_is_ready)(BOA *somSelf, Environment *ev,
  127.         ImplementationDef* impl);
  128. typedef void   (SOMLINK * somTD_BOA_deactivate_impl)(BOA *somSelf, Environment *ev,
  129.         ImplementationDef* impl);
  130. typedef void   (SOMLINK * somTD_BOA_change_implementation)(BOA *somSelf, Environment *ev,
  131.         SOMDObject* obj,
  132.         ImplementationDef* impl);
  133. typedef void   (SOMLINK * somTD_BOA_obj_is_ready)(BOA *somSelf, Environment *ev,
  134.         SOMDObject* obj,
  135.         ImplementationDef* impl);
  136. typedef void   (SOMLINK * somTD_BOA_deactivate_obj)(BOA *somSelf, Environment *ev,
  137.         SOMDObject* obj);
  138.  
  139. /*
  140.  * -- Typedefs for Reintroduced Wrapper Methods
  141.  */
  142. typedef void   (SOMLINK * somTD_BOA_somDefaultInit)(BOA *somSelf,
  143.         somInitCtrl* ctrl);
  144. typedef void   (SOMLINK * somTD_BOA_somDestruct)(BOA *somSelf,
  145.         octet doFree,
  146.         somDestructCtrl* ctrl);
  147. typedef void   (SOMLINK * somTD_BOA_somDefaultCopyInit)(BOA *somSelf,
  148.         somInitCtrl* ctrl,
  149.         SOMObject* fromObj);
  150. typedef BOA*   (SOMLINK * somTD_BOA_somDefaultAssign)(BOA *somSelf,
  151.         somAssignCtrl* ctrl,
  152.         SOMObject* fromObj);
  153. typedef void   (SOMLINK * somTD_BOA_somDefaultConstCopyInit)(BOA *somSelf,
  154.         somInitCtrl* ctrl,
  155.         SOMObject* fromObj);
  156. typedef void   (SOMLINK * somTD_BOA_somDefaultVCopyInit)(BOA *somSelf,
  157.         somInitCtrl* ctrl,
  158.         SOMObject* fromObj);
  159. typedef void   (SOMLINK * somTD_BOA_somDefaultConstVCopyInit)(BOA *somSelf,
  160.         somInitCtrl* ctrl,
  161.         SOMObject* fromObj);
  162. typedef BOA*   (SOMLINK * somTD_BOA_somDefaultConstAssign)(BOA *somSelf,
  163.         somAssignCtrl* ctrl,
  164.         SOMObject* fromObj);
  165. typedef BOA*   (SOMLINK * somTD_BOA_somDefaultVAssign)(BOA *somSelf,
  166.         somAssignCtrl* ctrl,
  167.         SOMObject* fromObj);
  168. typedef BOA*   (SOMLINK * somTD_BOA_somDefaultConstVAssign)(BOA *somSelf,
  169.         somAssignCtrl* ctrl,
  170.         SOMObject* fromObj);
  171. typedef void   (SOMLINK * somTD_BOA_somInit)(BOA *somSelf);
  172. typedef void   (SOMLINK * somTD_BOA_somFree)(BOA *somSelf);
  173. typedef void   (SOMLINK * somTD_BOA_somUninit)(BOA *somSelf);
  174. typedef SOMMSingleInstance*   (SOMLINK * somTD_BOA_somGetClass)(BOA *somSelf);
  175. typedef string   (SOMLINK * somTD_BOA_somGetClassName)(BOA *somSelf);
  176. typedef long   (SOMLINK * somTD_BOA_somGetSize)(BOA *somSelf);
  177. typedef boolean   (SOMLINK * somTD_BOA_somIsA)(BOA *somSelf,
  178.         SOMClass* aClassObj);
  179. typedef boolean   (SOMLINK * somTD_BOA_somIsInstanceOf)(BOA *somSelf,
  180.         SOMClass* aClassObj);
  181. typedef boolean   (SOMLINK * somTD_BOA_somRespondsTo)(BOA *somSelf,
  182.         somId mId);
  183. typedef boolean   (SOMLINK * somTD_BOA_somDispatch)(BOA *somSelf,
  184.         somToken* retValue,
  185.         somId methodId,
  186.         va_list ap);
  187. typedef boolean   (SOMLINK * somTD_BOA_somClassDispatch)(BOA *somSelf,
  188.         SOMClass* clsObj,
  189.         somToken* retValue,
  190.         somId methodId,
  191.         va_list ap);
  192. typedef boolean   (SOMLINK * somTD_BOA_somCastObj)(BOA *somSelf,
  193.         SOMClass* cls);
  194. typedef boolean   (SOMLINK * somTD_BOA_somResetObj)(BOA *somSelf);
  195. typedef void   (SOMLINK * somTD_BOA_somDispatchV)(BOA *somSelf,
  196.         somId methodId,
  197.         somId descriptor,
  198.         va_list ap);
  199. typedef long   (SOMLINK * somTD_BOA_somDispatchL)(BOA *somSelf,
  200.         somId methodId,
  201.         somId descriptor,
  202.         va_list ap);
  203. typedef void*   (SOMLINK * somTD_BOA_somDispatchA)(BOA *somSelf,
  204.         somId methodId,
  205.         somId descriptor,
  206.         va_list ap);
  207. typedef double   (SOMLINK * somTD_BOA_somDispatchD)(BOA *somSelf,
  208.         somId methodId,
  209.         somId descriptor,
  210.         va_list ap);
  211. typedef SOMObject*   (SOMLINK * somTD_BOA_somPrintSelf)(BOA *somSelf);
  212. typedef void   (SOMLINK * somTD_BOA_somDumpSelf)(BOA *somSelf,
  213.         long level);
  214. typedef void   (SOMLINK * somTD_BOA_somDumpSelfInt)(BOA *somSelf,
  215.         long level);
  216. }
  217.  
  218. #endif /* BOA_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 BOA
  230.  */
  231. class BOA : public SOMObject
  232. {
  233. public:
  234.  
  235. // BOA::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 size)
  238. {
  239.    SOM_IgnoreWarning(size);
  240.    if (!_BOA) BOANewClass(BOA_MajorVersion,BOA_MinorVersion);
  241.    return (void*)
  242.       SOM_Resolve(_BOA,SOMClass,somNewNoInit)
  243.          ((SOMClass *)((void*)_BOA));
  244. }
  245.  
  246. // BOA::delete uses the default deallocator for the object's class.
  247. void operator delete(void * obj)
  248. {
  249.    somToken objCls = obj ? *(void**)obj : (somToken) NULL;
  250.    if (somIsObj(objCls)) {
  251.       SOM_Resolve(objCls,SOMClass,somDeallocate)
  252.          ((SOMClass*)objCls, (string)obj);
  253.    }
  254. }
  255.  
  256. BOA()
  257. {
  258.    if (*(void**)this != 
  259.        ((somParentMtabStructPtr)
  260.         (BOACClassData.parentMtab))->mtab)
  261.       return;
  262.    somDefaultInit(0);
  263. }
  264.  
  265. BOA(BOA* fromObj)
  266. {
  267.    if (*(void**)this != 
  268.        ((somParentMtabStructPtr)
  269.         (BOACClassData.parentMtab))->mtab)
  270.       return;
  271.    somDefaultCopyInit(0,((SOMObject*)((void*)fromObj)));
  272. }
  273.  
  274. BOA(const BOA* fromObj)
  275. {
  276.    if (*(void**)this != 
  277.        ((somParentMtabStructPtr)
  278.         (BOACClassData.parentMtab))->mtab)
  279.       return;
  280.    somDefaultConstCopyInit(0,((SOMObject*)((void*)fromObj)));
  281. }
  282.  
  283. ~BOA()
  284. {
  285.    if (!somIsObj(this)) return;
  286.    somDestruct(0,0);
  287.    *(void**)this = **(void***)this;
  288. }
  289.  
  290.  
  291. /* method: create */
  292. SOMDObject*   create(Environment *ev,
  293.         ReferenceData* id,
  294.         InterfaceDef* intf,
  295.         ImplementationDef* impl)
  296. {
  297.    return SOM_ResolveD(this,BOA,BOA,create)
  298.     (this, ev,id,intf,impl);
  299. }
  300.  
  301.  
  302. /* method: dispose */
  303. void   dispose(Environment *ev,
  304.         SOMDObject* obj)
  305. {
  306.    SOM_ResolveD(this,BOA,BOA,dispose)
  307.     (this, ev,obj);
  308. }
  309.  
  310.  
  311. /* method: get_id */
  312. ReferenceData   get_id(Environment *ev,
  313.         SOMDObject* obj)
  314. {
  315.    return SOM_ResolveD(this,BOA,BOA,get_id)
  316.     (this, ev,obj);
  317. }
  318.  
  319.  
  320. /* method: get_principal */
  321. Principal*   get_principal(Environment *ev,
  322.         SOMDObject* obj,
  323.         Environment* req_ev)
  324. {
  325.    return SOM_ResolveD(this,BOA,BOA,get_principal)
  326.     (this, ev,obj,req_ev);
  327. }
  328.  
  329.  
  330. /* method: set_exception */
  331. void   set_exception(Environment *ev,
  332.         exception_type major,
  333.         string userid,
  334.         void* param)
  335. {
  336.    SOM_ResolveD(this,BOA,BOA,set_exception)
  337.     (this, ev,major,userid,param);
  338. }
  339.  
  340.  
  341. /* method: impl_is_ready */
  342. void   impl_is_ready(Environment *ev,
  343.         ImplementationDef* impl)
  344. {
  345.    SOM_ResolveD(this,BOA,BOA,impl_is_ready)
  346.     (this, ev,impl);
  347. }
  348.  
  349.  
  350. /* method: deactivate_impl */
  351. void   deactivate_impl(Environment *ev,
  352.         ImplementationDef* impl)
  353. {
  354.    SOM_ResolveD(this,BOA,BOA,deactivate_impl)
  355.     (this, ev,impl);
  356. }
  357.  
  358.  
  359. /* method: change_implementation */
  360. void   change_implementation(Environment *ev,
  361.         SOMDObject* obj,
  362.         ImplementationDef* impl)
  363. {
  364.    SOM_ResolveD(this,BOA,BOA,change_implementation)
  365.     (this, ev,obj,impl);
  366. }
  367.  
  368.  
  369. /* method: obj_is_ready */
  370. void   obj_is_ready(Environment *ev,
  371.         SOMDObject* obj,
  372.         ImplementationDef* impl)
  373. {
  374.    SOM_ResolveD(this,BOA,BOA,obj_is_ready)
  375.     (this, ev,obj,impl);
  376. }
  377.  
  378.  
  379. /* method: deactivate_obj */
  380. void   deactivate_obj(Environment *ev,
  381.         SOMDObject* obj)
  382. {
  383.    SOM_ResolveD(this,BOA,BOA,deactivate_obj)
  384.     (this, ev,obj);
  385. }
  386.  
  387.  
  388. /*
  389.  * Reintroduce inherited methods
  390.  */
  391.  
  392. /* initializer method: somDefaultInit */
  393. void   somDefaultInit(somInitCtrl* ctrl)
  394. {
  395.    SOM_ResolveD(this,BOA,SOMObject,somDefaultInit)
  396.     (this,ctrl);
  397. }
  398.  
  399.  
  400. /* method: somDestruct */
  401. void   somDestruct(octet doFree,
  402.         somDestructCtrl* ctrl)
  403. {
  404.    SOM_ResolveD(this,BOA,SOMObject,somDestruct)
  405.     (this,doFree,ctrl);
  406. }
  407.  
  408.  
  409. /* method: somDefaultCopyInit */
  410. void   somDefaultCopyInit(somInitCtrl* ctrl,
  411.         SOMObject* fromObj)
  412. {
  413.    SOM_ResolveD(this,BOA,SOMObject,somDefaultCopyInit)
  414.     (this,ctrl,fromObj);
  415. }
  416.  
  417.  
  418. /* method: somDefaultAssign */
  419. BOA*  somDefaultAssign(somAssignCtrl* ctrl,
  420.         SOMObject* fromObj)
  421. {
  422.    return SOM_ResolveD(this,BOA,SOMObject,somDefaultAssign)
  423.     (this,ctrl,fromObj);
  424. }
  425.  
  426.  
  427. /* method: somDefaultConstCopyInit */
  428. void   somDefaultConstCopyInit(somInitCtrl* ctrl,
  429.         SOMObject* fromObj)
  430. {
  431.    SOM_ResolveD(this,BOA,SOMObject,somDefaultConstCopyInit)
  432.     (this,ctrl,fromObj);
  433. }
  434.  
  435.  
  436. /* method: somDefaultVCopyInit */
  437. void   somDefaultVCopyInit(somInitCtrl* ctrl,
  438.         SOMObject* fromObj)
  439. {
  440.    SOM_ResolveD(this,BOA,SOMObject,somDefaultVCopyInit)
  441.     (this,ctrl,fromObj);
  442. }
  443.  
  444.  
  445. /* method: somDefaultConstVCopyInit */
  446. void   somDefaultConstVCopyInit(somInitCtrl* ctrl,
  447.         SOMObject* fromObj)
  448. {
  449.    SOM_ResolveD(this,BOA,SOMObject,somDefaultConstVCopyInit)
  450.     (this,ctrl,fromObj);
  451. }
  452.  
  453.  
  454. /* method: somDefaultConstAssign */
  455. BOA*  somDefaultConstAssign(somAssignCtrl* ctrl,
  456.         SOMObject* fromObj)
  457. {
  458.    return SOM_ResolveD(this,BOA,SOMObject,somDefaultConstAssign)
  459.     (this,ctrl,fromObj);
  460. }
  461.  
  462.  
  463. /* method: somDefaultVAssign */
  464. BOA*  somDefaultVAssign(somAssignCtrl* ctrl,
  465.         SOMObject* fromObj)
  466. {
  467.    return SOM_ResolveD(this,BOA,SOMObject,somDefaultVAssign)
  468.     (this,ctrl,fromObj);
  469. }
  470.  
  471.  
  472. /* method: somDefaultConstVAssign */
  473. BOA*  somDefaultConstVAssign(somAssignCtrl* ctrl,
  474.         SOMObject* fromObj)
  475. {
  476.    return SOM_ResolveD(this,BOA,SOMObject,somDefaultConstVAssign)
  477.     (this,ctrl,fromObj);
  478. }
  479.  
  480.  
  481. /* method: somInit */
  482. void   somInit()
  483. {
  484.    SOM_ResolveD(this,BOA,SOMObject,somInit)
  485.     (this);
  486. }
  487.  
  488.  
  489. /* method: somFree */
  490. void   somFree()
  491. {
  492.    SOM_ResolveD(this,BOA,SOMObject,somFree)
  493.     (this);
  494. }
  495.  
  496.  
  497. /* method: somUninit */
  498. void   somUninit()
  499. {
  500.    SOM_ResolveD(this,BOA,SOMObject,somUninit)
  501.     (this);
  502. }
  503.  
  504.  
  505. /* method: somGetClass */
  506. SOMMSingleInstance*  somGetClass()
  507. {
  508.    return SOM_ResolveD(this,BOA,SOMObject,somGetClass)
  509.     (this);
  510. }
  511.  
  512.  
  513. /* method: somGetClassName */
  514. string   somGetClassName()
  515. {
  516.    return SOM_ResolveD(this,BOA,SOMObject,somGetClassName)
  517.     (this);
  518. }
  519.  
  520.  
  521. /* method: somGetSize */
  522. long   somGetSize()
  523. {
  524.    return SOM_ResolveD(this,BOA,SOMObject,somGetSize)
  525.     (this);
  526. }
  527.  
  528.  
  529. /* method: somIsA */
  530. boolean   somIsA(SOMClass* aClassObj)
  531. {
  532.    return SOM_ResolveD(this,BOA,SOMObject,somIsA)
  533.     (this,aClassObj);
  534. }
  535.  
  536.  
  537. /* method: somIsInstanceOf */
  538. boolean   somIsInstanceOf(SOMClass* aClassObj)
  539. {
  540.    return SOM_ResolveD(this,BOA,SOMObject,somIsInstanceOf)
  541.     (this,aClassObj);
  542. }
  543.  
  544.  
  545. /* method: somRespondsTo */
  546. boolean   somRespondsTo(somId mId)
  547. {
  548.    return SOM_ResolveD(this,BOA,SOMObject,somRespondsTo)
  549.     (this,mId);
  550. }
  551.  
  552.  
  553. /* va_list method: somDispatch */
  554. /* the va_list invocation form */
  555. boolean   BOA_somDispatch(somToken* retValue,
  556.         somId methodId,
  557.         va_list ap)
  558. {
  559. return SOM_ResolveD(this,BOA,SOMObject,somDispatch)
  560.     (this,retValue,methodId,ap);
  561. }
  562.  
  563. /* the varargs invocation form */
  564. boolean   somDispatch(somToken* retValue,
  565.         somId methodId,
  566.         ...)
  567. {
  568.    va_list ap;
  569.    va_start(ap, methodId);
  570.    boolean __somResult = 
  571.       SOM_ResolveD(this,BOA,SOMObject,somDispatch)
  572.     (this,retValue,methodId,ap);
  573.    va_end(ap);
  574.    return __somResult;
  575. }
  576.  
  577.  
  578. /* va_list method: somClassDispatch */
  579. /* the va_list invocation form */
  580. boolean   BOA_somClassDispatch(SOMClass* clsObj,
  581.         somToken* retValue,
  582.         somId methodId,
  583.         va_list ap)
  584. {
  585. return SOM_ResolveD(this,BOA,SOMObject,somClassDispatch)
  586.     (this,clsObj,retValue,methodId,ap);
  587. }
  588.  
  589. /* the varargs invocation form */
  590. boolean   somClassDispatch(SOMClass* clsObj,
  591.         somToken* retValue,
  592.         somId methodId,
  593.         ...)
  594. {
  595.    va_list ap;
  596.    va_start(ap, methodId);
  597.    boolean __somResult = 
  598.       SOM_ResolveD(this,BOA,SOMObject,somClassDispatch)
  599.     (this,clsObj,retValue,methodId,ap);
  600.    va_end(ap);
  601.    return __somResult;
  602. }
  603.  
  604.  
  605. /* method: somCastObj */
  606. boolean   somCastObj(SOMClass* cls)
  607. {
  608.    return SOM_ResolveD(this,BOA,SOMObject,somCastObj)
  609.     (this,cls);
  610. }
  611.  
  612.  
  613. /* method: somResetObj */
  614. boolean   somResetObj()
  615. {
  616.    return SOM_ResolveD(this,BOA,SOMObject,somResetObj)
  617.     (this);
  618. }
  619.  
  620.  
  621. /* va_list method: somDispatchV */
  622. /* the va_list invocation form */
  623. void   BOA_somDispatchV(somId methodId,
  624.         somId descriptor,
  625.         va_list ap)
  626. {
  627.    SOM_ResolveD(this,BOA,SOMObject,somDispatchV)
  628.     (this,methodId,descriptor,ap);
  629. }
  630.  
  631. /* the varargs invocation form */
  632. void   somDispatchV(somId methodId,
  633.         somId descriptor,
  634.         ...)
  635. {
  636.    va_list ap;
  637.    va_start(ap, descriptor);
  638.    SOM_ResolveD(this,BOA,SOMObject,somDispatchV)
  639.     (this,methodId,descriptor,ap);
  640.    va_end(ap);
  641. }
  642.  
  643.  
  644. /* va_list method: somDispatchL */
  645. /* the va_list invocation form */
  646. long   BOA_somDispatchL(somId methodId,
  647.         somId descriptor,
  648.         va_list ap)
  649. {
  650. return SOM_ResolveD(this,BOA,SOMObject,somDispatchL)
  651.     (this,methodId,descriptor,ap);
  652. }
  653.  
  654. /* the varargs invocation form */
  655. long   somDispatchL(somId methodId,
  656.         somId descriptor,
  657.         ...)
  658. {
  659.    va_list ap;
  660.    va_start(ap, descriptor);
  661.    long __somResult = 
  662.       SOM_ResolveD(this,BOA,SOMObject,somDispatchL)
  663.     (this,methodId,descriptor,ap);
  664.    va_end(ap);
  665.    return __somResult;
  666. }
  667.  
  668.  
  669. /* va_list method: somDispatchA */
  670. /* the va_list invocation form */
  671. void*   BOA_somDispatchA(somId methodId,
  672.         somId descriptor,
  673.         va_list ap)
  674. {
  675. return SOM_ResolveD(this,BOA,SOMObject,somDispatchA)
  676.     (this,methodId,descriptor,ap);
  677. }
  678.  
  679. /* the varargs invocation form */
  680. void*   somDispatchA(somId methodId,
  681.         somId descriptor,
  682.         ...)
  683. {
  684.    va_list ap;
  685.    va_start(ap, descriptor);
  686.    void* __somResult = 
  687.       SOM_ResolveD(this,BOA,SOMObject,somDispatchA)
  688.     (this,methodId,descriptor,ap);
  689.    va_end(ap);
  690.    return __somResult;
  691. }
  692.  
  693.  
  694. /* va_list method: somDispatchD */
  695. /* the va_list invocation form */
  696. double   BOA_somDispatchD(somId methodId,
  697.         somId descriptor,
  698.         va_list ap)
  699. {
  700. return SOM_ResolveD(this,BOA,SOMObject,somDispatchD)
  701.     (this,methodId,descriptor,ap);
  702. }
  703.  
  704. /* the varargs invocation form */
  705. double   somDispatchD(somId methodId,
  706.         somId descriptor,
  707.         ...)
  708. {
  709.    va_list ap;
  710.    va_start(ap, descriptor);
  711.    double __somResult = 
  712.       SOM_ResolveD(this,BOA,SOMObject,somDispatchD)
  713.     (this,methodId,descriptor,ap);
  714.    va_end(ap);
  715.    return __somResult;
  716. }
  717.  
  718.  
  719. /* method: somPrintSelf */
  720. SOMObject*   somPrintSelf()
  721. {
  722.    return SOM_ResolveD(this,BOA,SOMObject,somPrintSelf)
  723.     (this);
  724. }
  725.  
  726.  
  727. /* method: somDumpSelf */
  728. void   somDumpSelf(long level)
  729. {
  730.    SOM_ResolveD(this,BOA,SOMObject,somDumpSelf)
  731.     (this,level);
  732. }
  733.  
  734.  
  735. /* method: somDumpSelfInt */
  736. void   somDumpSelfInt(long level)
  737. {
  738.    SOM_ResolveD(this,BOA,SOMObject,somDumpSelfInt)
  739.     (this,level);
  740. }
  741.  
  742.  
  743.  
  744. };   /* BOA */
  745.  
  746.  
  747.  
  748. #endif       /* SOM_BOA_xh */
  749.