home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / warptlk3.zip / TOOLKIT / SOM / INCLUDE / SOMCM.XH < prev    next >
Text File  |  1995-08-30  |  23KB  |  855 lines
  1.  
  2. /*
  3.  * This file was generated by the SOM Compiler.
  4.  * FileName: somcm.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: somk
  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.  *   SOMClassMgr: System Object Model class manager
  24.  */
  25.  
  26.  
  27. #ifndef SOM_SOMClassMgr_xh
  28. #define SOM_SOMClassMgr_xh
  29.  
  30. class SOMClassMgr;
  31.  
  32. #define SOMClassMgr_MajorVersion 1
  33. #define SOMClassMgr_MinorVersion 4
  34.  
  35. /* C++ SOM defs */
  36. #include <somcls.xh>
  37.  
  38. /* C++ parent defs */
  39. #ifndef SOM_SOMObject_xh
  40. #include <somobj.xh>
  41. #endif
  42.  
  43. #ifndef SOMClassMgr_API
  44. #define SOMClassMgr_API
  45. /*
  46.  * -- The Class API
  47.  */
  48.  
  49. /*
  50.  * Start of user-defined types:
  51.  */
  52. class SOMClass;
  53. class SOMObject;
  54. class Repository;
  55. typedef
  56. SOMClass* SOMClassMgr_SOMClassArray;
  57.  
  58. /*
  59.  *  Used for SOM 1.0 binary compatibility
  60.  */
  61. #ifndef _IDL_SEQUENCE_SOMClass_defined
  62. #define _IDL_SEQUENCE_SOMClass_defined
  63. typedef struct {
  64.     unsigned long _maximum;
  65.     unsigned long _length;
  66.     SOMClass **_buffer;
  67. } _IDL_SEQUENCE_SOMClass;
  68. #endif /* _IDL_SEQUENCE_SOMClass_defined */ 
  69.  
  70. #ifndef SOM_DONT_USE_SHORT_NAMES
  71. #ifndef SOMTGD_SOMClassArray
  72.     #ifdef SOMClassArray
  73.         #undef SOMClassArray
  74.         #define SOMTGD_SOMClassArray 1
  75.     #else
  76.         #define SOMClassArray SOMClassMgr_SOMClassArray
  77.     #endif /* SOMClassArray */
  78. #endif /* SOMTGD_SOMClassArray */
  79. #endif /* SOM_DONT_USE_SHORT_NAMES */
  80.  
  81. #ifndef SOM_DONT_USE_SHORT_NAMES
  82. #endif /* SOM_DONT_USE_SHORT_NAMES */
  83.  
  84. /*
  85.  * End of user-defined types.
  86.  */
  87.  
  88. /* A procedure to create the SOMClassMgr Class */
  89. SOMEXTERN SOMClass * SOMLINK SOMClassMgrNewClass(
  90.         integer4 majorVersion,
  91.         integer4 minorVersion);
  92.  
  93. /* The API to the SOMClassMgr class object, and the methods it introduces. */
  94. SOMEXTERN struct SOMClassMgrClassDataStructure {
  95.     SOMClass *classObject;
  96.     somMToken somFindClsInFile;
  97.     somMToken somFindClass;
  98.     somMToken somClassFromId;
  99.     somMToken somRegisterClass;
  100.     somMToken somUnregisterClass;
  101.     somMToken somLocateClassFile;
  102.     somMToken somLoadClassFile;
  103.     somMToken somUnloadClassFile;
  104.     somMToken somGetInitFunction;
  105.     somMToken somMergeInto;
  106.     somMToken somGetRelatedClasses;
  107.     somMToken somSubstituteClass;
  108.     somMToken _get_somInterfaceRepository;
  109.     somMToken _set_somInterfaceRepository;
  110.     somMToken _get_somRegisteredClasses;
  111.     somMToken somBeginPersistentClasses;
  112.     somMToken somEndPersistentClasses;
  113.     somMToken somcmPrivate1;
  114.     somMToken somcmPrivate2;
  115.     somMToken somRegisterClassLibrary;
  116.     somMToken somJoinAffinityGroup;
  117. } SOMDLINK SOMClassMgrClassData;
  118. #define _SOMClassMgr SOMClassMgrClassData.classObject
  119.  
  120. /* The API to parentMtabs for SOMClassMgr, and the instance data it introduces. */
  121. SOMEXTERN struct SOMClassMgrCClassDataStructure {
  122.     somMethodTabs parentMtab;
  123.     somDToken              instanceDataToken;
  124. } SOMDLINK SOMClassMgrCClassData;
  125.  
  126. /*
  127.  * -- Typedefs for SOMClassMgr Method Procedures
  128.  */
  129. SOMEXTERN {
  130. typedef SOMClass*   (SOMLINK * somTD_SOMClassMgr_somLoadClassFile)(SOMClassMgr *somSelf,
  131.         somId classId,
  132.         long majorVersion,
  133.         long minorVersion,
  134.         string file);
  135. typedef string   (SOMLINK * somTD_SOMClassMgr_somLocateClassFile)(SOMClassMgr *somSelf,
  136.         somId classId,
  137.         long majorVersion,
  138.         long minorVersion);
  139. typedef void   (SOMLINK * somTD_SOMClassMgr_somRegisterClass)(SOMClassMgr *somSelf,
  140.         SOMClass* classObj);
  141. typedef void   (SOMLINK * somTD_SOMClassMgr_somRegisterClassLibrary)(SOMClassMgr *somSelf,
  142.         string libraryName,
  143.         somMethodPtr libraryInitRtn);
  144. typedef long   (SOMLINK * somTD_SOMClassMgr_somUnloadClassFile)(SOMClassMgr *somSelf,
  145.         SOMClass* classObj);
  146. typedef long   (SOMLINK * somTD_SOMClassMgr_somUnregisterClass)(SOMClassMgr *somSelf,
  147.         SOMClass* classObj);
  148. typedef void   (SOMLINK * somTD_SOMClassMgr_somBeginPersistentClasses)(SOMClassMgr *somSelf);
  149. typedef void   (SOMLINK * somTD_SOMClassMgr_somEndPersistentClasses)(SOMClassMgr *somSelf);
  150. typedef boolean   (SOMLINK * somTD_SOMClassMgr_somJoinAffinityGroup)(SOMClassMgr *somSelf,
  151.         SOMClass* newClass,
  152.         SOMClass* affClass);
  153. typedef string   (SOMLINK * somTD_SOMClassMgr_somGetInitFunction)(SOMClassMgr *somSelf);
  154. typedef Repository*   (SOMLINK * somTD_SOMClassMgr__get_somInterfaceRepository)(SOMClassMgr *somSelf);
  155. typedef void   (SOMLINK * somTD_SOMClassMgr__set_somInterfaceRepository)(SOMClassMgr *somSelf,
  156.         Repository* somInterfaceRepository);
  157. typedef _IDL_SEQUENCE_SOMClass   (SOMLINK * somTD_SOMClassMgr__get_somRegisteredClasses)(SOMClassMgr *somSelf);
  158. typedef SOMClassMgr_SOMClassArray   (SOMLINK * somTD_SOMClassMgr_somGetRelatedClasses)(SOMClassMgr *somSelf,
  159.         SOMClass* classObj);
  160. typedef SOMClass*   (SOMLINK * somTD_SOMClassMgr_somClassFromId)(SOMClassMgr *somSelf,
  161.         somId classId);
  162. typedef SOMClass*   (SOMLINK * somTD_SOMClassMgr_somFindClass)(SOMClassMgr *somSelf,
  163.         somId classId,
  164.         long majorVersion,
  165.         long minorVersion);
  166. typedef SOMClass*   (SOMLINK * somTD_SOMClassMgr_somFindClsInFile)(SOMClassMgr *somSelf,
  167.         somId classId,
  168.         long majorVersion,
  169.         long minorVersion,
  170.         string file);
  171. typedef void   (SOMLINK * somTD_SOMClassMgr_somMergeInto)(SOMClassMgr *somSelf,
  172.         SOMObject* targetObj);
  173. typedef long   (SOMLINK * somTD_SOMClassMgr_somSubstituteClass)(SOMClassMgr *somSelf,
  174.         string origClassName,
  175.         string newClassName);
  176.  
  177. /*
  178.  * -- Typedefs for Reintroduced Wrapper Methods
  179.  */
  180. typedef void   (SOMLINK * somTD_SOMClassMgr_somDefaultInit)(SOMClassMgr *somSelf,
  181.         somInitCtrl* ctrl);
  182. typedef void   (SOMLINK * somTD_SOMClassMgr_somDestruct)(SOMClassMgr *somSelf,
  183.         octet doFree,
  184.         somDestructCtrl* ctrl);
  185. typedef void   (SOMLINK * somTD_SOMClassMgr_somDefaultCopyInit)(SOMClassMgr *somSelf,
  186.         somInitCtrl* ctrl,
  187.         SOMObject* fromObj);
  188. typedef SOMClassMgr*   (SOMLINK * somTD_SOMClassMgr_somDefaultAssign)(SOMClassMgr *somSelf,
  189.         somAssignCtrl* ctrl,
  190.         SOMObject* fromObj);
  191. typedef void   (SOMLINK * somTD_SOMClassMgr_somDefaultConstCopyInit)(SOMClassMgr *somSelf,
  192.         somInitCtrl* ctrl,
  193.         SOMObject* fromObj);
  194. typedef void   (SOMLINK * somTD_SOMClassMgr_somDefaultVCopyInit)(SOMClassMgr *somSelf,
  195.         somInitCtrl* ctrl,
  196.         SOMObject* fromObj);
  197. typedef void   (SOMLINK * somTD_SOMClassMgr_somDefaultConstVCopyInit)(SOMClassMgr *somSelf,
  198.         somInitCtrl* ctrl,
  199.         SOMObject* fromObj);
  200. typedef SOMClassMgr*   (SOMLINK * somTD_SOMClassMgr_somDefaultConstAssign)(SOMClassMgr *somSelf,
  201.         somAssignCtrl* ctrl,
  202.         SOMObject* fromObj);
  203. typedef SOMClassMgr*   (SOMLINK * somTD_SOMClassMgr_somDefaultVAssign)(SOMClassMgr *somSelf,
  204.         somAssignCtrl* ctrl,
  205.         SOMObject* fromObj);
  206. typedef SOMClassMgr*   (SOMLINK * somTD_SOMClassMgr_somDefaultConstVAssign)(SOMClassMgr *somSelf,
  207.         somAssignCtrl* ctrl,
  208.         SOMObject* fromObj);
  209. typedef void   (SOMLINK * somTD_SOMClassMgr_somInit)(SOMClassMgr *somSelf);
  210. typedef void   (SOMLINK * somTD_SOMClassMgr_somFree)(SOMClassMgr *somSelf);
  211. typedef void   (SOMLINK * somTD_SOMClassMgr_somUninit)(SOMClassMgr *somSelf);
  212. typedef SOMClass*   (SOMLINK * somTD_SOMClassMgr_somGetClass)(SOMClassMgr *somSelf);
  213. typedef string   (SOMLINK * somTD_SOMClassMgr_somGetClassName)(SOMClassMgr *somSelf);
  214. typedef long   (SOMLINK * somTD_SOMClassMgr_somGetSize)(SOMClassMgr *somSelf);
  215. typedef boolean   (SOMLINK * somTD_SOMClassMgr_somIsA)(SOMClassMgr *somSelf,
  216.         SOMClass* aClassObj);
  217. typedef boolean   (SOMLINK * somTD_SOMClassMgr_somIsInstanceOf)(SOMClassMgr *somSelf,
  218.         SOMClass* aClassObj);
  219. typedef boolean   (SOMLINK * somTD_SOMClassMgr_somRespondsTo)(SOMClassMgr *somSelf,
  220.         somId mId);
  221. typedef boolean   (SOMLINK * somTD_SOMClassMgr_somDispatch)(SOMClassMgr *somSelf,
  222.         somToken* retValue,
  223.         somId methodId,
  224.         va_list ap);
  225. typedef boolean   (SOMLINK * somTD_SOMClassMgr_somClassDispatch)(SOMClassMgr *somSelf,
  226.         SOMClass* clsObj,
  227.         somToken* retValue,
  228.         somId methodId,
  229.         va_list ap);
  230. typedef boolean   (SOMLINK * somTD_SOMClassMgr_somCastObj)(SOMClassMgr *somSelf,
  231.         SOMClass* cls);
  232. typedef boolean   (SOMLINK * somTD_SOMClassMgr_somResetObj)(SOMClassMgr *somSelf);
  233. typedef void   (SOMLINK * somTD_SOMClassMgr_somDispatchV)(SOMClassMgr *somSelf,
  234.         somId methodId,
  235.         somId descriptor,
  236.         va_list ap);
  237. typedef long   (SOMLINK * somTD_SOMClassMgr_somDispatchL)(SOMClassMgr *somSelf,
  238.         somId methodId,
  239.         somId descriptor,
  240.         va_list ap);
  241. typedef void*   (SOMLINK * somTD_SOMClassMgr_somDispatchA)(SOMClassMgr *somSelf,
  242.         somId methodId,
  243.         somId descriptor,
  244.         va_list ap);
  245. typedef double   (SOMLINK * somTD_SOMClassMgr_somDispatchD)(SOMClassMgr *somSelf,
  246.         somId methodId,
  247.         somId descriptor,
  248.         va_list ap);
  249. typedef SOMObject*   (SOMLINK * somTD_SOMClassMgr_somPrintSelf)(SOMClassMgr *somSelf);
  250. typedef void   (SOMLINK * somTD_SOMClassMgr_somDumpSelf)(SOMClassMgr *somSelf,
  251.         long level);
  252. typedef void   (SOMLINK * somTD_SOMClassMgr_somDumpSelfInt)(SOMClassMgr *somSelf,
  253.         long level);
  254. }
  255.  
  256. #endif /* SOMClassMgr_API */
  257.  
  258.  
  259. /*
  260.  * -- This emitter treats Method Tokens as Thunks by default.
  261.  * -- Use the sc modifier "nothunks" to change this default
  262.  */
  263. #undef somresolve_
  264. #define somresolve_(obj,mToken) ((somMethodProc*)((void)obj, mToken))
  265.  
  266. /*
  267.  * -- The C++ Wrapper Class for SOMClassMgr
  268.  */
  269. class SOMClassMgr : public SOMObject
  270. {
  271. public:
  272.  
  273. // SOMClassMgr::new creates the class object if necessary, and then uses somNewNoInit
  274. // to allocate memory and create the object. Initialization is in ctors.
  275. void *operator new(size_t size)
  276. {
  277.    SOM_IgnoreWarning(size);
  278.    if (!_SOMClassMgr) SOMClassMgrNewClass(SOMClassMgr_MajorVersion,SOMClassMgr_MinorVersion);
  279.    return (void*)
  280.       SOM_Resolve(_SOMClassMgr,SOMClass,somNewNoInit)
  281.          ((SOMClass *)((void*)_SOMClassMgr));
  282. }
  283.  
  284. // SOMClassMgr::delete uses the default deallocator for the object's class.
  285. void operator delete(void * obj)
  286. {
  287.    somToken objCls = obj ? *(void**)obj : (somToken) NULL;
  288.    if (somIsObj(objCls)) {
  289.       SOM_Resolve(objCls,SOMClass,somDeallocate)
  290.          ((SOMClass*)objCls, (string)obj);
  291.    }
  292. }
  293.  
  294. SOMClassMgr()
  295. {
  296.    if (*(void**)this != 
  297.        ((somParentMtabStructPtr)
  298.         (SOMClassMgrCClassData.parentMtab))->mtab)
  299.       return;
  300.    somDefaultInit(0);
  301. }
  302.  
  303. SOMClassMgr(SOMClassMgr* fromObj)
  304. {
  305.    if (*(void**)this != 
  306.        ((somParentMtabStructPtr)
  307.         (SOMClassMgrCClassData.parentMtab))->mtab)
  308.       return;
  309.    somDefaultCopyInit(0,((SOMObject*)((void*)fromObj)));
  310. }
  311.  
  312. SOMClassMgr(const SOMClassMgr* fromObj)
  313. {
  314.    if (*(void**)this != 
  315.        ((somParentMtabStructPtr)
  316.         (SOMClassMgrCClassData.parentMtab))->mtab)
  317.       return;
  318.    somDefaultConstCopyInit(0,((SOMObject*)((void*)fromObj)));
  319. }
  320.  
  321. ~SOMClassMgr()
  322. {
  323.    if (!somIsObj(this)) return;
  324.    somDestruct(0,0);
  325.    *(void**)this = **(void***)this;
  326. }
  327.  
  328.  
  329. /* method: somLoadClassFile */
  330. SOMClass*   somLoadClassFile(somId classId,
  331.         long majorVersion,
  332.         long minorVersion,
  333.         string file)
  334. {
  335.    return SOM_ResolveD(this,SOMClassMgr,SOMClassMgr,somLoadClassFile)
  336.     (this,classId,majorVersion,minorVersion,file);
  337. }
  338.  
  339.  
  340. /* method: somLocateClassFile */
  341. string   somLocateClassFile(somId classId,
  342.         long majorVersion,
  343.         long minorVersion)
  344. {
  345.    return SOM_ResolveD(this,SOMClassMgr,SOMClassMgr,somLocateClassFile)
  346.     (this,classId,majorVersion,minorVersion);
  347. }
  348.  
  349.  
  350. /* method: somRegisterClass */
  351. void   somRegisterClass(SOMClass* classObj)
  352. {
  353.    SOM_ResolveD(this,SOMClassMgr,SOMClassMgr,somRegisterClass)
  354.     (this,classObj);
  355. }
  356.  
  357.  
  358. /* method: somRegisterClassLibrary */
  359. void   somRegisterClassLibrary(string libraryName,
  360.         somMethodPtr libraryInitRtn)
  361. {
  362.    SOM_ResolveD(this,SOMClassMgr,SOMClassMgr,somRegisterClassLibrary)
  363.     (this,libraryName,libraryInitRtn);
  364. }
  365.  
  366.  
  367. /* method: somUnloadClassFile */
  368. long   somUnloadClassFile(SOMClass* classObj)
  369. {
  370.    return SOM_ResolveD(this,SOMClassMgr,SOMClassMgr,somUnloadClassFile)
  371.     (this,classObj);
  372. }
  373.  
  374.  
  375. /* method: somUnregisterClass */
  376. long   somUnregisterClass(SOMClass* classObj)
  377. {
  378.    return SOM_ResolveD(this,SOMClassMgr,SOMClassMgr,somUnregisterClass)
  379.     (this,classObj);
  380. }
  381.  
  382.  
  383. /* method: somBeginPersistentClasses */
  384. void   somBeginPersistentClasses()
  385. {
  386.    SOM_ResolveD(this,SOMClassMgr,SOMClassMgr,somBeginPersistentClasses)
  387.     (this);
  388. }
  389.  
  390.  
  391. /* method: somEndPersistentClasses */
  392. void   somEndPersistentClasses()
  393. {
  394.    SOM_ResolveD(this,SOMClassMgr,SOMClassMgr,somEndPersistentClasses)
  395.     (this);
  396. }
  397.  
  398.  
  399. /* method: somJoinAffinityGroup */
  400. boolean   somJoinAffinityGroup(SOMClass* newClass,
  401.         SOMClass* affClass)
  402. {
  403.    return SOM_ResolveD(this,SOMClassMgr,SOMClassMgr,somJoinAffinityGroup)
  404.     (this,newClass,affClass);
  405. }
  406.  
  407.  
  408. /* method: somGetInitFunction */
  409. string   somGetInitFunction()
  410. {
  411.    return SOM_ResolveD(this,SOMClassMgr,SOMClassMgr,somGetInitFunction)
  412.     (this);
  413. }
  414.  
  415.  
  416. /* method: _get_somInterfaceRepository */
  417. Repository*   _get_somInterfaceRepository()
  418. {
  419.    return SOM_ResolveD(this,SOMClassMgr,SOMClassMgr,_get_somInterfaceRepository)
  420.     (this);
  421. }
  422.  
  423.  
  424. /* method: _set_somInterfaceRepository */
  425. void   _set_somInterfaceRepository(Repository* somInterfaceRepository)
  426. {
  427.    SOM_ResolveD(this,SOMClassMgr,SOMClassMgr,_set_somInterfaceRepository)
  428.     (this,somInterfaceRepository);
  429. }
  430.  
  431.  
  432. /* method: _get_somRegisteredClasses */
  433. _IDL_SEQUENCE_SOMClass   _get_somRegisteredClasses()
  434. {
  435.    return SOM_ResolveD(this,SOMClassMgr,SOMClassMgr,_get_somRegisteredClasses)
  436.     (this);
  437. }
  438.  
  439.  
  440. /* method: somGetRelatedClasses */
  441. SOMClassMgr_SOMClassArray   somGetRelatedClasses(SOMClass* classObj)
  442. {
  443.    return SOM_ResolveD(this,SOMClassMgr,SOMClassMgr,somGetRelatedClasses)
  444.     (this,classObj);
  445. }
  446.  
  447.  
  448. /* method: somClassFromId */
  449. SOMClass*   somClassFromId(somId classId)
  450. {
  451.    return SOM_ResolveD(this,SOMClassMgr,SOMClassMgr,somClassFromId)
  452.     (this,classId);
  453. }
  454.  
  455.  
  456. /* method: somFindClass */
  457. SOMClass*   somFindClass(somId classId,
  458.         long majorVersion,
  459.         long minorVersion)
  460. {
  461.    return SOM_ResolveD(this,SOMClassMgr,SOMClassMgr,somFindClass)
  462.     (this,classId,majorVersion,minorVersion);
  463. }
  464.  
  465.  
  466. /* method: somFindClsInFile */
  467. SOMClass*   somFindClsInFile(somId classId,
  468.         long majorVersion,
  469.         long minorVersion,
  470.         string file)
  471. {
  472.    return SOM_ResolveD(this,SOMClassMgr,SOMClassMgr,somFindClsInFile)
  473.     (this,classId,majorVersion,minorVersion,file);
  474. }
  475.  
  476.  
  477. /* method: somMergeInto */
  478. void   somMergeInto(SOMObject* targetObj)
  479. {
  480.    SOM_ResolveD(this,SOMClassMgr,SOMClassMgr,somMergeInto)
  481.     (this,targetObj);
  482. }
  483.  
  484.  
  485. /* method: somSubstituteClass */
  486. long   somSubstituteClass(string origClassName,
  487.         string newClassName)
  488. {
  489.    return SOM_ResolveD(this,SOMClassMgr,SOMClassMgr,somSubstituteClass)
  490.     (this,origClassName,newClassName);
  491. }
  492.  
  493.  
  494. /*
  495.  * Reintroduce inherited methods
  496.  */
  497.  
  498. /* initializer method: somDefaultInit */
  499. void   somDefaultInit(somInitCtrl* ctrl)
  500. {
  501.    SOM_ResolveD(this,SOMClassMgr,SOMObject,somDefaultInit)
  502.     (this,ctrl);
  503. }
  504.  
  505.  
  506. /* method: somDestruct */
  507. void   somDestruct(octet doFree,
  508.         somDestructCtrl* ctrl)
  509. {
  510.    SOM_ResolveD(this,SOMClassMgr,SOMObject,somDestruct)
  511.     (this,doFree,ctrl);
  512. }
  513.  
  514.  
  515. /* method: somDefaultCopyInit */
  516. void   somDefaultCopyInit(somInitCtrl* ctrl,
  517.         SOMObject* fromObj)
  518. {
  519.    SOM_ResolveD(this,SOMClassMgr,SOMObject,somDefaultCopyInit)
  520.     (this,ctrl,fromObj);
  521. }
  522.  
  523.  
  524. /* method: somDefaultAssign */
  525. SOMClassMgr*  somDefaultAssign(somAssignCtrl* ctrl,
  526.         SOMObject* fromObj)
  527. {
  528.    return SOM_ResolveD(this,SOMClassMgr,SOMObject,somDefaultAssign)
  529.     (this,ctrl,fromObj);
  530. }
  531.  
  532.  
  533. /* method: somDefaultConstCopyInit */
  534. void   somDefaultConstCopyInit(somInitCtrl* ctrl,
  535.         SOMObject* fromObj)
  536. {
  537.    SOM_ResolveD(this,SOMClassMgr,SOMObject,somDefaultConstCopyInit)
  538.     (this,ctrl,fromObj);
  539. }
  540.  
  541.  
  542. /* method: somDefaultVCopyInit */
  543. void   somDefaultVCopyInit(somInitCtrl* ctrl,
  544.         SOMObject* fromObj)
  545. {
  546.    SOM_ResolveD(this,SOMClassMgr,SOMObject,somDefaultVCopyInit)
  547.     (this,ctrl,fromObj);
  548. }
  549.  
  550.  
  551. /* method: somDefaultConstVCopyInit */
  552. void   somDefaultConstVCopyInit(somInitCtrl* ctrl,
  553.         SOMObject* fromObj)
  554. {
  555.    SOM_ResolveD(this,SOMClassMgr,SOMObject,somDefaultConstVCopyInit)
  556.     (this,ctrl,fromObj);
  557. }
  558.  
  559.  
  560. /* method: somDefaultConstAssign */
  561. SOMClassMgr*  somDefaultConstAssign(somAssignCtrl* ctrl,
  562.         SOMObject* fromObj)
  563. {
  564.    return SOM_ResolveD(this,SOMClassMgr,SOMObject,somDefaultConstAssign)
  565.     (this,ctrl,fromObj);
  566. }
  567.  
  568.  
  569. /* method: somDefaultVAssign */
  570. SOMClassMgr*  somDefaultVAssign(somAssignCtrl* ctrl,
  571.         SOMObject* fromObj)
  572. {
  573.    return SOM_ResolveD(this,SOMClassMgr,SOMObject,somDefaultVAssign)
  574.     (this,ctrl,fromObj);
  575. }
  576.  
  577.  
  578. /* method: somDefaultConstVAssign */
  579. SOMClassMgr*  somDefaultConstVAssign(somAssignCtrl* ctrl,
  580.         SOMObject* fromObj)
  581. {
  582.    return SOM_ResolveD(this,SOMClassMgr,SOMObject,somDefaultConstVAssign)
  583.     (this,ctrl,fromObj);
  584. }
  585.  
  586.  
  587. /* method: somInit */
  588. void   somInit()
  589. {
  590.    SOM_ResolveD(this,SOMClassMgr,SOMObject,somInit)
  591.     (this);
  592. }
  593.  
  594.  
  595. /* method: somFree */
  596. void   somFree()
  597. {
  598.    SOM_ResolveD(this,SOMClassMgr,SOMObject,somFree)
  599.     (this);
  600. }
  601.  
  602.  
  603. /* method: somUninit */
  604. void   somUninit()
  605. {
  606.    SOM_ResolveD(this,SOMClassMgr,SOMObject,somUninit)
  607.     (this);
  608. }
  609.  
  610.  
  611. /* method: somGetClass */
  612. SOMClass*   somGetClass()
  613. {
  614.    return SOM_ResolveD(this,SOMClassMgr,SOMObject,somGetClass)
  615.     (this);
  616. }
  617.  
  618.  
  619. /* method: somGetClassName */
  620. string   somGetClassName()
  621. {
  622.    return SOM_ResolveD(this,SOMClassMgr,SOMObject,somGetClassName)
  623.     (this);
  624. }
  625.  
  626.  
  627. /* method: somGetSize */
  628. long   somGetSize()
  629. {
  630.    return SOM_ResolveD(this,SOMClassMgr,SOMObject,somGetSize)
  631.     (this);
  632. }
  633.  
  634.  
  635. /* method: somIsA */
  636. boolean   somIsA(SOMClass* aClassObj)
  637. {
  638.    return SOM_ResolveD(this,SOMClassMgr,SOMObject,somIsA)
  639.     (this,aClassObj);
  640. }
  641.  
  642.  
  643. /* method: somIsInstanceOf */
  644. boolean   somIsInstanceOf(SOMClass* aClassObj)
  645. {
  646.    return SOM_ResolveD(this,SOMClassMgr,SOMObject,somIsInstanceOf)
  647.     (this,aClassObj);
  648. }
  649.  
  650.  
  651. /* method: somRespondsTo */
  652. boolean   somRespondsTo(somId mId)
  653. {
  654.    return SOM_ResolveD(this,SOMClassMgr,SOMObject,somRespondsTo)
  655.     (this,mId);
  656. }
  657.  
  658.  
  659. /* va_list method: somDispatch */
  660. /* the va_list invocation form */
  661. boolean   SOMClassMgr_somDispatch(somToken* retValue,
  662.         somId methodId,
  663.         va_list ap)
  664. {
  665. return SOM_ResolveD(this,SOMClassMgr,SOMObject,somDispatch)
  666.     (this,retValue,methodId,ap);
  667. }
  668.  
  669. /* the varargs invocation form */
  670. boolean   somDispatch(somToken* retValue,
  671.         somId methodId,
  672.         ...)
  673. {
  674.    va_list ap;
  675.    va_start(ap, methodId);
  676.    boolean __somResult = 
  677.       SOM_ResolveD(this,SOMClassMgr,SOMObject,somDispatch)
  678.     (this,retValue,methodId,ap);
  679.    va_end(ap);
  680.    return __somResult;
  681. }
  682.  
  683.  
  684. /* va_list method: somClassDispatch */
  685. /* the va_list invocation form */
  686. boolean   SOMClassMgr_somClassDispatch(SOMClass* clsObj,
  687.         somToken* retValue,
  688.         somId methodId,
  689.         va_list ap)
  690. {
  691. return SOM_ResolveD(this,SOMClassMgr,SOMObject,somClassDispatch)
  692.     (this,clsObj,retValue,methodId,ap);
  693. }
  694.  
  695. /* the varargs invocation form */
  696. boolean   somClassDispatch(SOMClass* clsObj,
  697.         somToken* retValue,
  698.         somId methodId,
  699.         ...)
  700. {
  701.    va_list ap;
  702.    va_start(ap, methodId);
  703.    boolean __somResult = 
  704.       SOM_ResolveD(this,SOMClassMgr,SOMObject,somClassDispatch)
  705.     (this,clsObj,retValue,methodId,ap);
  706.    va_end(ap);
  707.    return __somResult;
  708. }
  709.  
  710.  
  711. /* method: somCastObj */
  712. boolean   somCastObj(SOMClass* cls)
  713. {
  714.    return SOM_ResolveD(this,SOMClassMgr,SOMObject,somCastObj)
  715.     (this,cls);
  716. }
  717.  
  718.  
  719. /* method: somResetObj */
  720. boolean   somResetObj()
  721. {
  722.    return SOM_ResolveD(this,SOMClassMgr,SOMObject,somResetObj)
  723.     (this);
  724. }
  725.  
  726.  
  727. /* va_list method: somDispatchV */
  728. /* the va_list invocation form */
  729. void   SOMClassMgr_somDispatchV(somId methodId,
  730.         somId descriptor,
  731.         va_list ap)
  732. {
  733.    SOM_ResolveD(this,SOMClassMgr,SOMObject,somDispatchV)
  734.     (this,methodId,descriptor,ap);
  735. }
  736.  
  737. /* the varargs invocation form */
  738. void   somDispatchV(somId methodId,
  739.         somId descriptor,
  740.         ...)
  741. {
  742.    va_list ap;
  743.    va_start(ap, descriptor);
  744.    SOM_ResolveD(this,SOMClassMgr,SOMObject,somDispatchV)
  745.     (this,methodId,descriptor,ap);
  746.    va_end(ap);
  747. }
  748.  
  749.  
  750. /* va_list method: somDispatchL */
  751. /* the va_list invocation form */
  752. long   SOMClassMgr_somDispatchL(somId methodId,
  753.         somId descriptor,
  754.         va_list ap)
  755. {
  756. return SOM_ResolveD(this,SOMClassMgr,SOMObject,somDispatchL)
  757.     (this,methodId,descriptor,ap);
  758. }
  759.  
  760. /* the varargs invocation form */
  761. long   somDispatchL(somId methodId,
  762.         somId descriptor,
  763.         ...)
  764. {
  765.    va_list ap;
  766.    va_start(ap, descriptor);
  767.    long __somResult = 
  768.       SOM_ResolveD(this,SOMClassMgr,SOMObject,somDispatchL)
  769.     (this,methodId,descriptor,ap);
  770.    va_end(ap);
  771.    return __somResult;
  772. }
  773.  
  774.  
  775. /* va_list method: somDispatchA */
  776. /* the va_list invocation form */
  777. void*   SOMClassMgr_somDispatchA(somId methodId,
  778.         somId descriptor,
  779.         va_list ap)
  780. {
  781. return SOM_ResolveD(this,SOMClassMgr,SOMObject,somDispatchA)
  782.     (this,methodId,descriptor,ap);
  783. }
  784.  
  785. /* the varargs invocation form */
  786. void*   somDispatchA(somId methodId,
  787.         somId descriptor,
  788.         ...)
  789. {
  790.    va_list ap;
  791.    va_start(ap, descriptor);
  792.    void* __somResult = 
  793.       SOM_ResolveD(this,SOMClassMgr,SOMObject,somDispatchA)
  794.     (this,methodId,descriptor,ap);
  795.    va_end(ap);
  796.    return __somResult;
  797. }
  798.  
  799.  
  800. /* va_list method: somDispatchD */
  801. /* the va_list invocation form */
  802. double   SOMClassMgr_somDispatchD(somId methodId,
  803.         somId descriptor,
  804.         va_list ap)
  805. {
  806. return SOM_ResolveD(this,SOMClassMgr,SOMObject,somDispatchD)
  807.     (this,methodId,descriptor,ap);
  808. }
  809.  
  810. /* the varargs invocation form */
  811. double   somDispatchD(somId methodId,
  812.         somId descriptor,
  813.         ...)
  814. {
  815.    va_list ap;
  816.    va_start(ap, descriptor);
  817.    double __somResult = 
  818.       SOM_ResolveD(this,SOMClassMgr,SOMObject,somDispatchD)
  819.     (this,methodId,descriptor,ap);
  820.    va_end(ap);
  821.    return __somResult;
  822. }
  823.  
  824.  
  825. /* method: somPrintSelf */
  826. SOMObject*   somPrintSelf()
  827. {
  828.    return SOM_ResolveD(this,SOMClassMgr,SOMObject,somPrintSelf)
  829.     (this);
  830. }
  831.  
  832.  
  833. /* method: somDumpSelf */
  834. void   somDumpSelf(long level)
  835. {
  836.    SOM_ResolveD(this,SOMClassMgr,SOMObject,somDumpSelf)
  837.     (this,level);
  838. }
  839.  
  840.  
  841. /* method: somDumpSelfInt */
  842. void   somDumpSelfInt(long level)
  843. {
  844.    SOM_ResolveD(this,SOMClassMgr,SOMObject,somDumpSelfInt)
  845.     (this,level);
  846. }
  847.  
  848.  
  849.  
  850. };   /* SOMClassMgr */
  851.  
  852.  
  853.  
  854. #endif       /* SOM_SOMClassMgr_xh */
  855.