home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / tolkit45.zip / os2tk45 / som / include / implrep.xh < prev    next >
Text File  |  1999-02-22  |  31KB  |  1,004 lines
  1.  
  2. /*
  3.  * This file was generated by the SOM Compiler.
  4.  * FileName: implrep.xh.
  5.  * Generated using:
  6.  *     SOM Precompiler somipc: 2.29.1.17
  7.  *     SOM Emitter emitxh: 2.47
  8.  */
  9.  
  10. /*
  11.  *   CLASS SPECIFICATION FOR IMPLEMENTATION REPOSITORY
  12.  */
  13.  
  14.  
  15. #ifndef SOM_ImplRepository_xh
  16. #define SOM_ImplRepository_xh
  17.  
  18. class ImplRepository;
  19.  
  20. #define ImplRepository_MajorVersion 2
  21. #define ImplRepository_MinorVersion 1
  22.  
  23. /* C++ SOM defs */
  24. #include <somcls.xh>
  25. #include <somcm.xh>
  26.  
  27. /* C++ parent defs */
  28. #ifndef SOM_SOMObject_xh
  29. #include <somobj.xh>
  30. #endif
  31.  
  32. /*
  33.  * C++ metaclass def
  34.  */
  35. #include <snglicls.xh>
  36.  
  37. #ifndef ImplRepository_API
  38. #define ImplRepository_API
  39. /*
  40.  * -- The Class API
  41.  */
  42.  
  43. /*
  44.  * Start of bindings for IDL types
  45.  */
  46.  
  47. class SOMClass;
  48. class SOMObject;
  49. class Container;
  50. class ImplementationDef;
  51. #ifndef _IDL_SEQUENCE_ImplementationDef_defined
  52. #define _IDL_SEQUENCE_ImplementationDef_defined
  53. typedef struct {
  54.     unsigned long _maximum;
  55.     unsigned long _length;
  56.     ImplementationDef **_buffer;
  57. } _IDL_SEQUENCE_ImplementationDef;
  58. #endif /* _IDL_SEQUENCE_ImplementationDef_defined */ 
  59. #ifndef _IDL_SEQUENCE_string_defined
  60. #define _IDL_SEQUENCE_string_defined
  61. typedef struct {
  62.     unsigned long _maximum;
  63.     unsigned long _length;
  64.     string *_buffer;
  65. } _IDL_SEQUENCE_string;
  66. #endif /* _IDL_SEQUENCE_string_defined */ 
  67.  
  68. #ifndef SOM_DONT_USE_SHORT_NAMES
  69. #endif /* SOM_DONT_USE_SHORT_NAMES */
  70.  
  71. /*
  72.  * End of bindings for IDL types.
  73.  */
  74.  
  75. /*
  76.  * Passthru lines: File: "C.xh", "after"
  77.  */
  78.  
  79. class ImplRepository;
  80. #include <impldef.xh>
  81.  
  82. SOMEXTERN ImplRepository * SOMDLINK SOMD_ImplRepObject;
  83.  
  84.  
  85. /* A procedure to create the ImplRepository Class */
  86. class SOMMSingleInstance;
  87. SOMEXTERN SOMMSingleInstance * SOMLINK ImplRepositoryNewClass(
  88.         integer4 majorVersion,
  89.         integer4 minorVersion);
  90.  
  91. /* The API to the ImplRepository class object, and the methods it introduces. */
  92. SOMEXTERN struct ImplRepositoryClassDataStructure {
  93.     SOMMSingleInstance *classObject;
  94.     somMToken find_impldef;
  95.     somMToken find_impldef_by_alias;
  96.     somMToken find_impldef2;
  97.     somMToken find_impldef_by_alias2;
  98.     somMToken find_impldef_by_class;
  99.     somMToken add_impldef;
  100.     somMToken update_impldef;
  101.     somMToken delete_impldef;
  102.     somMToken add_class_to_impldef;
  103.     somMToken remove_class_from_impldef;
  104.     somMToken remove_class_from_all;
  105.     somMToken find_classes_by_impldef;
  106.     somMToken implr_get_impl;
  107.     somMToken implr_search_impl;
  108.     somMToken implr_search_class;
  109.     somMToken implr_update_impl;
  110.     somMToken find_all_impldefs;
  111. } SOMDLINK ImplRepositoryClassData;
  112. #define _ImplRepository ImplRepositoryClassData.classObject
  113.  
  114. /* The API to parentMtabs for ImplRepository, and the instance data it introduces. */
  115. SOMEXTERN struct ImplRepositoryCClassDataStructure {
  116.     somMethodTabs parentMtab;
  117.     somDToken              instanceDataToken;
  118. } SOMDLINK ImplRepositoryCClassData;
  119.  
  120. /*
  121.  * -- Typedefs for ImplRepository Method Procedures
  122.  */
  123. SOMEXTERN {
  124. typedef ImplementationDef*   SOMLINK somTP_ImplRepository_find_impldef(ImplRepository *somSelf, Environment *ev, 
  125.         ImplId implid);
  126. typedef somTP_ImplRepository_find_impldef *somTD_ImplRepository_find_impldef;
  127. typedef ImplementationDef*   SOMLINK somTP_ImplRepository_find_impldef_by_alias(ImplRepository *somSelf, Environment *ev, 
  128.         string alias_name);
  129. typedef somTP_ImplRepository_find_impldef_by_alias *somTD_ImplRepository_find_impldef_by_alias;
  130. typedef ORBStatus   SOMLINK somTP_ImplRepository_find_all_impldefs(ImplRepository *somSelf, Environment *ev, 
  131.         _IDL_SEQUENCE_ImplementationDef* outimpldefs);
  132. typedef somTP_ImplRepository_find_all_impldefs *somTD_ImplRepository_find_all_impldefs;
  133. typedef _IDL_SEQUENCE_ImplementationDef   SOMLINK somTP_ImplRepository_find_impldef_by_class(ImplRepository *somSelf, Environment *ev, 
  134.         string classname);
  135. typedef somTP_ImplRepository_find_impldef_by_class *somTD_ImplRepository_find_impldef_by_class;
  136. typedef void   SOMLINK somTP_ImplRepository_add_impldef(ImplRepository *somSelf, Environment *ev, 
  137.         ImplementationDef* impldef);
  138. typedef somTP_ImplRepository_add_impldef *somTD_ImplRepository_add_impldef;
  139. typedef void   SOMLINK somTP_ImplRepository_update_impldef(ImplRepository *somSelf, Environment *ev, 
  140.         ImplementationDef* impldef);
  141. typedef somTP_ImplRepository_update_impldef *somTD_ImplRepository_update_impldef;
  142. typedef void   SOMLINK somTP_ImplRepository_delete_impldef(ImplRepository *somSelf, Environment *ev, 
  143.         ImplId implid);
  144. typedef somTP_ImplRepository_delete_impldef *somTD_ImplRepository_delete_impldef;
  145. typedef void   SOMLINK somTP_ImplRepository_add_class_to_impldef(ImplRepository *somSelf, Environment *ev, 
  146.         ImplId implid, 
  147.         string classname);
  148. typedef somTP_ImplRepository_add_class_to_impldef *somTD_ImplRepository_add_class_to_impldef;
  149. typedef void   SOMLINK somTP_ImplRepository_remove_class_from_impldef(ImplRepository *somSelf, Environment *ev, 
  150.         ImplId implid, 
  151.         string classname);
  152. typedef somTP_ImplRepository_remove_class_from_impldef *somTD_ImplRepository_remove_class_from_impldef;
  153. typedef void   SOMLINK somTP_ImplRepository_remove_class_from_all(ImplRepository *somSelf, Environment *ev, 
  154.         string classname);
  155. typedef somTP_ImplRepository_remove_class_from_all *somTD_ImplRepository_remove_class_from_all;
  156. typedef _IDL_SEQUENCE_string   SOMLINK somTP_ImplRepository_find_classes_by_impldef(ImplRepository *somSelf, Environment *ev, 
  157.         ImplId implid);
  158. typedef somTP_ImplRepository_find_classes_by_impldef *somTD_ImplRepository_find_classes_by_impldef;
  159.  
  160. /*
  161.  * -- Typedefs for Reintroduced Wrapper Methods
  162.  */
  163. typedef void   SOMLINK somTP_ImplRepository_somDefaultInit(ImplRepository *somSelf, 
  164.         som3InitCtrl* ctrl);
  165. typedef somTP_ImplRepository_somDefaultInit *somTD_ImplRepository_somDefaultInit;
  166. typedef void   SOMLINK somTP_ImplRepository_somDestruct(ImplRepository *somSelf, 
  167.         octet doFree, 
  168.         som3DestructCtrl* ctrl);
  169. typedef somTP_ImplRepository_somDestruct *somTD_ImplRepository_somDestruct;
  170. typedef void   SOMLINK somTP_ImplRepository_somDefaultCopyInit(ImplRepository *somSelf, 
  171.         som3InitCtrl* ctrl, 
  172.         SOMObject* fromObj);
  173. typedef somTP_ImplRepository_somDefaultCopyInit *somTD_ImplRepository_somDefaultCopyInit;
  174. typedef ImplRepository*   SOMLINK somTP_ImplRepository_somDefaultAssign(ImplRepository *somSelf, 
  175.         som3AssignCtrl* ctrl, 
  176.         SOMObject* fromObj);
  177. typedef somTP_ImplRepository_somDefaultAssign *somTD_ImplRepository_somDefaultAssign;
  178. typedef void   SOMLINK somTP_ImplRepository_somDefaultConstCopyInit(ImplRepository *somSelf, 
  179.         som3InitCtrl* ctrl, 
  180.         SOMObject* fromObj);
  181. typedef somTP_ImplRepository_somDefaultConstCopyInit *somTD_ImplRepository_somDefaultConstCopyInit;
  182. typedef void   SOMLINK somTP_ImplRepository_somDefaultVCopyInit(ImplRepository *somSelf, 
  183.         som3InitCtrl* ctrl, 
  184.         SOMObject* fromObj);
  185. typedef somTP_ImplRepository_somDefaultVCopyInit *somTD_ImplRepository_somDefaultVCopyInit;
  186. typedef void   SOMLINK somTP_ImplRepository_somDefaultConstVCopyInit(ImplRepository *somSelf, 
  187.         som3InitCtrl* ctrl, 
  188.         SOMObject* fromObj);
  189. typedef somTP_ImplRepository_somDefaultConstVCopyInit *somTD_ImplRepository_somDefaultConstVCopyInit;
  190. typedef ImplRepository*   SOMLINK somTP_ImplRepository_somDefaultConstAssign(ImplRepository *somSelf, 
  191.         som3AssignCtrl* ctrl, 
  192.         SOMObject* fromObj);
  193. typedef somTP_ImplRepository_somDefaultConstAssign *somTD_ImplRepository_somDefaultConstAssign;
  194. typedef ImplRepository*   SOMLINK somTP_ImplRepository_somDefaultVAssign(ImplRepository *somSelf, 
  195.         som3AssignCtrl* ctrl, 
  196.         SOMObject* fromObj);
  197. typedef somTP_ImplRepository_somDefaultVAssign *somTD_ImplRepository_somDefaultVAssign;
  198. typedef ImplRepository*   SOMLINK somTP_ImplRepository_somDefaultConstVAssign(ImplRepository *somSelf, 
  199.         som3AssignCtrl* ctrl, 
  200.         SOMObject* fromObj);
  201. typedef somTP_ImplRepository_somDefaultConstVAssign *somTD_ImplRepository_somDefaultConstVAssign;
  202. typedef void   SOMLINK somTP_ImplRepository_somInit(ImplRepository *somSelf);
  203. typedef somTP_ImplRepository_somInit *somTD_ImplRepository_somInit;
  204. typedef void   SOMLINK somTP_ImplRepository_somFree(ImplRepository *somSelf);
  205. typedef somTP_ImplRepository_somFree *somTD_ImplRepository_somFree;
  206. typedef void   SOMLINK somTP_ImplRepository_somUninit(ImplRepository *somSelf);
  207. typedef somTP_ImplRepository_somUninit *somTD_ImplRepository_somUninit;
  208. typedef SOMMSingleInstance*   SOMLINK somTP_ImplRepository_somGetClass(ImplRepository *somSelf);
  209. typedef somTP_ImplRepository_somGetClass *somTD_ImplRepository_somGetClass;
  210. typedef string   SOMLINK somTP_ImplRepository_somGetClassName(ImplRepository *somSelf);
  211. typedef somTP_ImplRepository_somGetClassName *somTD_ImplRepository_somGetClassName;
  212. typedef long   SOMLINK somTP_ImplRepository_somGetSize(ImplRepository *somSelf);
  213. typedef somTP_ImplRepository_somGetSize *somTD_ImplRepository_somGetSize;
  214. typedef boolean   SOMLINK somTP_ImplRepository_somIsA(ImplRepository *somSelf, 
  215.         SOMClass* aClassObj);
  216. typedef somTP_ImplRepository_somIsA *somTD_ImplRepository_somIsA;
  217. typedef boolean   SOMLINK somTP_ImplRepository_somIsInstanceOf(ImplRepository *somSelf, 
  218.         SOMClass* aClassObj);
  219. typedef somTP_ImplRepository_somIsInstanceOf *somTD_ImplRepository_somIsInstanceOf;
  220. typedef boolean   SOMLINK somTP_ImplRepository_somRespondsTo(ImplRepository *somSelf, 
  221.         somId mId);
  222. typedef somTP_ImplRepository_somRespondsTo *somTD_ImplRepository_somRespondsTo;
  223. typedef boolean   SOMLINK somTP_ImplRepository_somDispatch(ImplRepository *somSelf, 
  224.         somToken* retValue, 
  225.         somId methodId, 
  226.         va_list ap);
  227. typedef somTP_ImplRepository_somDispatch *somTD_ImplRepository_somDispatch;
  228. typedef boolean   SOMLINK somTP_ImplRepository_somClassDispatch(ImplRepository *somSelf, 
  229.         SOMClass* clsObj, 
  230.         somToken* retValue, 
  231.         somId methodId, 
  232.         va_list ap);
  233. typedef somTP_ImplRepository_somClassDispatch *somTD_ImplRepository_somClassDispatch;
  234. typedef boolean   SOMLINK somTP_ImplRepository_somCastObj(ImplRepository *somSelf, 
  235.         SOMClass* cls);
  236. typedef somTP_ImplRepository_somCastObj *somTD_ImplRepository_somCastObj;
  237. typedef boolean   SOMLINK somTP_ImplRepository_somResetObj(ImplRepository *somSelf);
  238. typedef somTP_ImplRepository_somResetObj *somTD_ImplRepository_somResetObj;
  239. typedef void   SOMLINK somTP_ImplRepository_somDispatchV(ImplRepository *somSelf, 
  240.         somId methodId, 
  241.         somId descriptor, 
  242.         va_list ap);
  243. typedef somTP_ImplRepository_somDispatchV *somTD_ImplRepository_somDispatchV;
  244. typedef long   SOMLINK somTP_ImplRepository_somDispatchL(ImplRepository *somSelf, 
  245.         somId methodId, 
  246.         somId descriptor, 
  247.         va_list ap);
  248. typedef somTP_ImplRepository_somDispatchL *somTD_ImplRepository_somDispatchL;
  249. typedef void*   SOMLINK somTP_ImplRepository_somDispatchA(ImplRepository *somSelf, 
  250.         somId methodId, 
  251.         somId descriptor, 
  252.         va_list ap);
  253. typedef somTP_ImplRepository_somDispatchA *somTD_ImplRepository_somDispatchA;
  254. typedef double   SOMLINK somTP_ImplRepository_somDispatchD(ImplRepository *somSelf, 
  255.         somId methodId, 
  256.         somId descriptor, 
  257.         va_list ap);
  258. typedef somTP_ImplRepository_somDispatchD *somTD_ImplRepository_somDispatchD;
  259. typedef SOMObject*   SOMLINK somTP_ImplRepository_somPrintSelf(ImplRepository *somSelf);
  260. typedef somTP_ImplRepository_somPrintSelf *somTD_ImplRepository_somPrintSelf;
  261. typedef void   SOMLINK somTP_ImplRepository_somDumpSelf(ImplRepository *somSelf, 
  262.         long level);
  263. typedef somTP_ImplRepository_somDumpSelf *somTD_ImplRepository_somDumpSelf;
  264. typedef void   SOMLINK somTP_ImplRepository_somDumpSelfInt(ImplRepository *somSelf, 
  265.         long level);
  266. typedef somTP_ImplRepository_somDumpSelfInt *somTD_ImplRepository_somDumpSelfInt;
  267. }
  268.  
  269. #endif /* ImplRepository_API */
  270.  
  271.  
  272. /*
  273.  * -- This emitter treats Method Tokens as Thunks by default.
  274.  * -- Use the sc modifier "nothunks" to change this default
  275.  */
  276. #undef somresolve_
  277. #define somresolve_(obj,mToken) ((somMethodProc*)((void)obj, mToken))
  278.  
  279. /*
  280.  * -- The C++ Wrapper Class for ImplRepository
  281.  */
  282. class ImplRepository : public SOMObject
  283. {
  284. public:
  285.  
  286. // ImplRepository::new creates the class object if necessary, and then uses somNewNoInit
  287. // to allocate memory and create the object. Initialization is in ctors.
  288. void *operator new(size_t)
  289. {
  290.    if (!_ImplRepository) ImplRepositoryNewClass(ImplRepository_MajorVersion,ImplRepository_MinorVersion);
  291.    return (void*)
  292.       SOM_Resolve(_ImplRepository,SOMClass,somNewNoInit)
  293.          ((SOMClass *)((void*)_ImplRepository));
  294. }
  295.  
  296. // ImplRepository::delete uses somDestruct.
  297. void operator delete(void * obj)
  298. {
  299.    if (obj && *(void**)obj) {
  300.       SOM_Resolve(obj,SOMObject,somFree)
  301.          ((SOMObject*)obj);
  302.    }
  303. }
  304.  
  305. ImplRepository& operator=(ImplRepository& fromObj)
  306. {
  307.    this->somDefaultAssign(0,(SOMObject*)((void*)&fromObj));
  308.    return *this;
  309. }
  310.  
  311. ImplRepository()
  312. {
  313.    if (*(void**)this != 
  314.        ((somParentMtabStructPtr)
  315.         (ImplRepositoryCClassData.parentMtab))->mtab)
  316.       return;
  317.    ((SOMObject*)((void*)this))->somDefaultInit(0);
  318. }
  319.  
  320. ImplRepository(ImplRepository* fromObj)
  321. {
  322.    if (*(void**)this != 
  323.        ((somParentMtabStructPtr)
  324.         (ImplRepositoryCClassData.parentMtab))->mtab)
  325.       return;
  326.    ((SOMObject*)((void*)this))->somDefaultCopyInit(0,((SOMObject*)((void*)fromObj)));
  327. }
  328.  
  329. #ifdef __IBMCPP__
  330. #pragma info(nocnv,nopar)
  331. #endif
  332. ImplRepository(const ImplRepository* fromObj)
  333. {
  334.    if (*(void**)this != 
  335.        ((somParentMtabStructPtr)
  336.         (ImplRepositoryCClassData.parentMtab))->mtab)
  337.       return;
  338.    ((SOMObject*)((void*)this))->somDefaultConstCopyInit(0,((SOMObject*)((void*)fromObj)));
  339. }
  340. #ifdef __IBMCPP__
  341. #pragma info(restore)
  342. #endif
  343.  
  344.  
  345. /* method: find_impldef */
  346. ImplementationDef*   find_impldef(Environment *ev, 
  347.         ImplId implid)
  348. {
  349. /*
  350.  *  This method searches the Implementation Repository and returns
  351.  *  an ImplementationDef object with the specified implid.
  352.  */
  353.    return SOM_ResolveD(this,ImplRepository,ImplRepository,find_impldef)
  354.     (this, ev,implid);
  355. }
  356.  
  357.  
  358. /* method: find_impldef_by_alias */
  359. ImplementationDef*   find_impldef_by_alias(Environment *ev, 
  360.         string alias_name)
  361. {
  362. /*
  363.  *  This method searches the Implementation Repository and returns
  364.  *  an ImplementationDef object with the specified name (alias).
  365.  */
  366.    return SOM_ResolveD(this,ImplRepository,ImplRepository,find_impldef_by_alias)
  367.     (this, ev,alias_name);
  368. }
  369.  
  370.  
  371. /* method: find_all_impldefs */
  372. ORBStatus   find_all_impldefs(Environment *ev, 
  373.         _IDL_SEQUENCE_ImplementationDef* outimpldefs)
  374. {
  375. /*
  376.  *  This method searches the Implementation Repository and returns
  377.  *  all the ImplementationDef objects in it.
  378.  */
  379.    return SOM_ResolveD(this,ImplRepository,ImplRepository,find_all_impldefs)
  380.     (this, ev,outimpldefs);
  381. }
  382.  
  383.  
  384. /* method: find_impldef_by_class */
  385. _IDL_SEQUENCE_ImplementationDef   find_impldef_by_class(Environment *ev, 
  386.         string classname)
  387. {
  388. /*
  389.  *  This method searches the class index and returns the sequence of
  390.  *  ImplementationDef objects for servers which implement that class.
  391.  */
  392.    return SOM_ResolveD(this,ImplRepository,ImplRepository,find_impldef_by_class)
  393.     (this, ev,classname);
  394. }
  395.  
  396.  
  397. /* method: add_impldef */
  398. void   add_impldef(Environment *ev, 
  399.         ImplementationDef* impldef)
  400. {
  401. /*
  402.  *  This method inserts an ImplementationDef object into the Implementation
  403.  *  Repository.
  404.  */
  405.    SOM_ResolveD(this,ImplRepository,ImplRepository,add_impldef)
  406.     (this, ev,impldef);
  407. }
  408.  
  409.  
  410. /* method: update_impldef */
  411. void   update_impldef(Environment *ev, 
  412.         ImplementationDef* impldef)
  413. {
  414. /*
  415.  *  This method replaces an ImplementationDef object in the Implementation
  416.  *  Repository with the supplied object.  The "impl_id" attribute of the
  417.  *  supplied object is used to find the object to replace in the Impl.
  418.  *  Repository.
  419.  */
  420.    SOM_ResolveD(this,ImplRepository,ImplRepository,update_impldef)
  421.     (this, ev,impldef);
  422. }
  423.  
  424.  
  425. /* method: delete_impldef */
  426. void   delete_impldef(Environment *ev, 
  427.         ImplId implid)
  428. {
  429. /*
  430.  *  This method deletes the ImplementationDef object with the specified
  431.  *  implid from the Implementation Repository.
  432.  */
  433.    SOM_ResolveD(this,ImplRepository,ImplRepository,delete_impldef)
  434.     (this, ev,implid);
  435. }
  436.  
  437.  
  438. /* method: add_class_to_impldef */
  439. void   add_class_to_impldef(Environment *ev, 
  440.         ImplId implid, 
  441.         string classname)
  442. {
  443. /*
  444.  *  This method associates the classname with the ImplementationDef
  445.  *  whose id is "implid".  This is meant to indicate that the server
  446.  *  (specified by the ImplementationDef) implements the named class.
  447.  */
  448.    SOM_ResolveD(this,ImplRepository,ImplRepository,add_class_to_impldef)
  449.     (this, ev,implid,classname);
  450. }
  451.  
  452.  
  453. /* method: remove_class_from_impldef */
  454. void   remove_class_from_impldef(Environment *ev, 
  455.         ImplId implid, 
  456.         string classname)
  457. {
  458. /*
  459.  *  This method removes the classname from the list of classnames
  460.  *  associated with the ImplementationDef whose id is "implid".
  461.  */
  462.    SOM_ResolveD(this,ImplRepository,ImplRepository,remove_class_from_impldef)
  463.     (this, ev,implid,classname);
  464. }
  465.  
  466.  
  467. /* method: remove_class_from_all */
  468. void   remove_class_from_all(Environment *ev, 
  469.         string classname)
  470. {
  471. /*
  472.  *  This method removes the classname from all the ImplementationDefs.
  473.  */
  474.    SOM_ResolveD(this,ImplRepository,ImplRepository,remove_class_from_all)
  475.     (this, ev,classname);
  476. }
  477.  
  478.  
  479. /* method: find_classes_by_impldef */
  480. _IDL_SEQUENCE_string   find_classes_by_impldef(Environment *ev, 
  481.         ImplId implid)
  482. {
  483. /*
  484.  *  This method searches the class index and returns the sequence of
  485.  *  class names supported by a server with specified "implid".
  486.  */
  487.    return SOM_ResolveD(this,ImplRepository,ImplRepository,find_classes_by_impldef)
  488.     (this, ev,implid);
  489. }
  490.  
  491.  
  492. /*
  493.  * Reintroduce inherited methods
  494.  */
  495.  
  496. /* initializer method: somDefaultInit */
  497. void   somDefaultInit(som3InitCtrl* ctrl)
  498. {
  499. /*
  500.  *  A default initializer for a SOM object. Passing a null ctrl
  501.  *  indicates to the receiver that its class is the class of the
  502.  *  object being initialized, whereby the initializer will determine
  503.  *  an appropriate control structure.
  504.  */
  505.    SOM_ResolveD(this,ImplRepository,SOMObject,somDefaultInit)
  506.     (this,ctrl);
  507. }
  508.  
  509.  
  510. /* method: somDestruct */
  511. void   somDestruct(octet doFree, 
  512.         som3DestructCtrl* ctrl)
  513. {
  514. /*
  515.  *  The default destructor for a SOM object. A nonzero <doFree>
  516.  *  indicates that the object storage should be freed by the
  517.  *  object's class (via somDeallocate) after uninitialization.
  518.  *  As with somDefaultInit, a null ctrl can be passed.
  519.  */
  520.    SOM_ResolveD(this,ImplRepository,SOMObject,somDestruct)
  521.     (this,doFree,ctrl);
  522. }
  523.  
  524.  
  525. /* initializer method: somDefaultCopyInit */
  526. void   somDefaultCopyInit(som3InitCtrl* ctrl, 
  527.         SOMObject* fromObj)
  528. {
  529. /*
  530.  *  A default copy constructor. Use this to make copies of objects for
  531.  *  calling methods with "by-value" argument semantics.
  532.  */
  533.    SOM_ResolveD(this,ImplRepository,SOMObject,somDefaultCopyInit)
  534.     (this,ctrl,fromObj);
  535. }
  536.  
  537.  
  538. /* method: somDefaultAssign */
  539. ImplRepository*  somDefaultAssign(som3AssignCtrl* ctrl, 
  540.         SOMObject* fromObj)
  541. {
  542. /*
  543.  *  A default assignment operator. Use this to "assign" the state of one
  544.  *  object to another.
  545.  */
  546.    return SOM_ResolveD(this,ImplRepository,SOMObject,somDefaultAssign)
  547.     (this,ctrl,fromObj);
  548. }
  549.  
  550.  
  551. /* initializer method: somDefaultConstCopyInit */
  552. void   somDefaultConstCopyInit(som3InitCtrl* ctrl, 
  553.         SOMObject* fromObj)
  554. {
  555. /*
  556.  *  A default copy constructor that uses a const fromObj.
  557.  */
  558.    SOM_ResolveD(this,ImplRepository,SOMObject,somDefaultConstCopyInit)
  559.     (this,ctrl,fromObj);
  560. }
  561.  
  562.  
  563. /* initializer method: somDefaultVCopyInit */
  564. void   somDefaultVCopyInit(som3InitCtrl* ctrl, 
  565.         SOMObject* fromObj)
  566. {
  567. /*
  568.  *  A default copy constructor that uses a volatile fromObj.
  569.  */
  570.    SOM_ResolveD(this,ImplRepository,SOMObject,somDefaultVCopyInit)
  571.     (this,ctrl,fromObj);
  572. }
  573.  
  574.  
  575. /* initializer method: somDefaultConstVCopyInit */
  576. void   somDefaultConstVCopyInit(som3InitCtrl* ctrl, 
  577.         SOMObject* fromObj)
  578. {
  579. /*
  580.  *  A default copy constructor that uses a const volatile fromObj.
  581.  */
  582.    SOM_ResolveD(this,ImplRepository,SOMObject,somDefaultConstVCopyInit)
  583.     (this,ctrl,fromObj);
  584. }
  585.  
  586.  
  587. /* method: somDefaultConstAssign */
  588. ImplRepository*  somDefaultConstAssign(som3AssignCtrl* ctrl, 
  589.         SOMObject* fromObj)
  590. {
  591. /*
  592.  *  A default assignment operator that uses a const fromObj.
  593.  */
  594.    return SOM_ResolveD(this,ImplRepository,SOMObject,somDefaultConstAssign)
  595.     (this,ctrl,fromObj);
  596. }
  597.  
  598.  
  599. /* method: somDefaultVAssign */
  600. ImplRepository*  somDefaultVAssign(som3AssignCtrl* ctrl, 
  601.         SOMObject* fromObj)
  602. {
  603. /*
  604.  *  A default assignment operator that uses a volatile fromObj.
  605.  */
  606.    return SOM_ResolveD(this,ImplRepository,SOMObject,somDefaultVAssign)
  607.     (this,ctrl,fromObj);
  608. }
  609.  
  610.  
  611. /* method: somDefaultConstVAssign */
  612. ImplRepository*  somDefaultConstVAssign(som3AssignCtrl* ctrl, 
  613.         SOMObject* fromObj)
  614. {
  615. /*
  616.  *  A default assignment operator that uses a const volatile fromObj.
  617.  */
  618.    return SOM_ResolveD(this,ImplRepository,SOMObject,somDefaultConstVAssign)
  619.     (this,ctrl,fromObj);
  620. }
  621.  
  622.  
  623. /* method: somInit */
  624. void   somInit()
  625. {
  626. /*
  627.  *  Obsolete but still supported. Override somDefaultInit instead of somInit.
  628.  */
  629.    SOM_ResolveD(this,ImplRepository,SOMObject,somInit)
  630.     (this);
  631. }
  632.  
  633.  
  634. /* method: somFree */
  635. void   somFree()
  636. {
  637. /*
  638.  *  Use as directed by framework implementations.
  639.  */
  640.    SOM_ResolveD(this,ImplRepository,SOMObject,somFree)
  641.     (this);
  642. }
  643.  
  644.  
  645. /* method: somUninit */
  646. void   somUninit()
  647. {
  648. /*
  649.  *  Obsolete but still supported. Override somDestruct instead of somUninit.
  650.  */
  651.    SOM_ResolveD(this,ImplRepository,SOMObject,somUninit)
  652.     (this);
  653. }
  654.  
  655.  
  656. /* method: somGetClass */
  657. SOMMSingleInstance*  somGetClass()
  658. {
  659. /*
  660.  *  Return the receiver's class.
  661.  */
  662.    return SOM_ResolveD(this,ImplRepository,SOMObject,somGetClass)
  663.     (this);
  664. }
  665.  
  666.  
  667. /* method: somGetClassName */
  668. string   somGetClassName()
  669. {
  670. /*
  671.  *  Return the name of the receiver's class.
  672.  */
  673.    return SOM_ResolveD(this,ImplRepository,SOMObject,somGetClassName)
  674.     (this);
  675. }
  676.  
  677.  
  678. /* method: somGetSize */
  679. long   somGetSize()
  680. {
  681. /*
  682.  *  Return the size of the receiver.
  683.  */
  684.    return SOM_ResolveD(this,ImplRepository,SOMObject,somGetSize)
  685.     (this);
  686. }
  687.  
  688.  
  689. /* method: somIsA */
  690. boolean   somIsA(SOMClass* aClassObj)
  691. {
  692. /*
  693.  *  Returns 1 (true) if the receiver responds to methods
  694.  *  introduced by <aClassObj>, and 0 (false) otherwise.
  695.  */
  696.    return SOM_ResolveD(this,ImplRepository,SOMObject,somIsA)
  697.     (this,aClassObj);
  698. }
  699.  
  700.  
  701. /* method: somIsInstanceOf */
  702. boolean   somIsInstanceOf(SOMClass* aClassObj)
  703. {
  704. /*
  705.  *  Returns 1 (true) if the receiver is an instance of
  706.  *  <aClassObj> and 0 (false) otherwise.
  707.  */
  708.    return SOM_ResolveD(this,ImplRepository,SOMObject,somIsInstanceOf)
  709.     (this,aClassObj);
  710. }
  711.  
  712.  
  713. /* method: somRespondsTo */
  714. boolean   somRespondsTo(somId mId)
  715. {
  716. /*
  717.  *  Returns 1 (true) if the indicated method can be invoked
  718.  *  on the receiver and 0 (false) otherwise.
  719.  */
  720.    return SOM_ResolveD(this,ImplRepository,SOMObject,somRespondsTo)
  721.     (this,mId);
  722. }
  723.  
  724.  
  725. /* va_list method: somDispatch */
  726.  
  727. /*
  728.  *  This method provides a generic, class-specific dispatch mechanism.
  729.  *  It accepts as input <retValue> a pointer to the memory area to be
  730.  *  loaded with the result of dispatching the method indicated by
  731.  *  <methodId> using the arguments in <ap>. <ap> contains the object
  732.  *  on which the method is to be invoked as the first argument.
  733.  */
  734. /* the va_list invocation form */
  735. boolean   ImplRepository_somDispatch(somToken* retValue, 
  736.         somId methodId, 
  737.         va_list ap)
  738. {return SOM_ResolveD(this,ImplRepository,SOMObject,somDispatch)
  739.     (this,retValue,methodId,ap);
  740. }
  741.  
  742. /* the varargs invocation form */
  743. boolean   somDispatch(somToken* retValue, 
  744.         somId methodId, 
  745.         ...)
  746. {
  747. /*
  748.  *  This method provides a generic, class-specific dispatch mechanism.
  749.  *  It accepts as input <retValue> a pointer to the memory area to be
  750.  *  loaded with the result of dispatching the method indicated by
  751.  *  <methodId> using the arguments in <ap>. <ap> contains the object
  752.  *  on which the method is to be invoked as the first argument.
  753.  */
  754.    va_list ap;
  755.    va_start(ap, methodId);
  756.    boolean __somResult = 
  757.       SOM_ResolveD(this,ImplRepository,SOMObject,somDispatch)
  758.     (this,retValue,methodId,ap);
  759.    va_end(ap);
  760.    return __somResult;
  761. }
  762.  
  763.  
  764. /* va_list method: somClassDispatch */
  765.  
  766. /*
  767.  *  Like somDispatch, but method resolution for static methods is done
  768.  *  according to the clsObj instance method table.
  769.  */
  770. /* the va_list invocation form */
  771. boolean   ImplRepository_somClassDispatch(SOMClass* clsObj, 
  772.         somToken* retValue, 
  773.         somId methodId, 
  774.         va_list ap)
  775. {return SOM_ResolveD(this,ImplRepository,SOMObject,somClassDispatch)
  776.     (this,clsObj,retValue,methodId,ap);
  777. }
  778.  
  779. /* the varargs invocation form */
  780. boolean   somClassDispatch(SOMClass* clsObj, 
  781.         somToken* retValue, 
  782.         somId methodId, 
  783.         ...)
  784. {
  785. /*
  786.  *  Like somDispatch, but method resolution for static methods is done
  787.  *  according to the clsObj instance method table.
  788.  */
  789.    va_list ap;
  790.    va_start(ap, methodId);
  791.    boolean __somResult = 
  792.       SOM_ResolveD(this,ImplRepository,SOMObject,somClassDispatch)
  793.     (this,clsObj,retValue,methodId,ap);
  794.    va_end(ap);
  795.    return __somResult;
  796. }
  797.  
  798.  
  799. /* method: somCastObj */
  800. boolean   somCastObj(SOMClass* cls)
  801. {
  802. /*
  803.  *  cast the receiving object to cls (which must be an ancestor of the
  804.  *  objects true class. Returns true on success.
  805.  */
  806.    return SOM_ResolveD(this,ImplRepository,SOMObject,somCastObj)
  807.     (this,cls);
  808. }
  809.  
  810.  
  811. /* method: somResetObj */
  812. boolean   somResetObj()
  813. {
  814. /*
  815.  *  reset an object to its true class. Returns true always.
  816.  */
  817.    return SOM_ResolveD(this,ImplRepository,SOMObject,somResetObj)
  818.     (this);
  819. }
  820.  
  821.  
  822. /* va_list method: somDispatchV */
  823.  
  824. /*
  825.  *  Obsolete. Use somDispatch instead.
  826.  */
  827. /* the va_list invocation form */
  828. void   ImplRepository_somDispatchV(somId methodId, 
  829.         somId descriptor, 
  830.         va_list ap)
  831. {   SOM_ResolveD(this,ImplRepository,SOMObject,somDispatchV)
  832.     (this,methodId,descriptor,ap);
  833. }
  834.  
  835. /* the varargs invocation form */
  836. void   somDispatchV(somId methodId, 
  837.         somId descriptor, 
  838.         ...)
  839. {
  840. /*
  841.  *  Obsolete. Use somDispatch instead.
  842.  */
  843.    va_list ap;
  844.    va_start(ap, descriptor);
  845.    SOM_ResolveD(this,ImplRepository,SOMObject,somDispatchV)
  846.     (this,methodId,descriptor,ap);
  847.    va_end(ap);
  848. }
  849.  
  850.  
  851. /* va_list method: somDispatchL */
  852.  
  853. /*
  854.  *  Obsolete. Use somDispatch instead.
  855.  */
  856. /* the va_list invocation form */
  857. long   ImplRepository_somDispatchL(somId methodId, 
  858.         somId descriptor, 
  859.         va_list ap)
  860. {return SOM_ResolveD(this,ImplRepository,SOMObject,somDispatchL)
  861.     (this,methodId,descriptor,ap);
  862. }
  863.  
  864. /* the varargs invocation form */
  865. long   somDispatchL(somId methodId, 
  866.         somId descriptor, 
  867.         ...)
  868. {
  869. /*
  870.  *  Obsolete. Use somDispatch instead.
  871.  */
  872.    va_list ap;
  873.    va_start(ap, descriptor);
  874.    long __somResult = 
  875.       SOM_ResolveD(this,ImplRepository,SOMObject,somDispatchL)
  876.     (this,methodId,descriptor,ap);
  877.    va_end(ap);
  878.    return __somResult;
  879. }
  880.  
  881.  
  882. /* va_list method: somDispatchA */
  883.  
  884. /*
  885.  *  Obsolete. Use somDispatch instead.
  886.  */
  887. /* the va_list invocation form */
  888. void*   ImplRepository_somDispatchA(somId methodId, 
  889.         somId descriptor, 
  890.         va_list ap)
  891. {return SOM_ResolveD(this,ImplRepository,SOMObject,somDispatchA)
  892.     (this,methodId,descriptor,ap);
  893. }
  894.  
  895. /* the varargs invocation form */
  896. void*   somDispatchA(somId methodId, 
  897.         somId descriptor, 
  898.         ...)
  899. {
  900. /*
  901.  *  Obsolete. Use somDispatch instead.
  902.  */
  903.    va_list ap;
  904.    va_start(ap, descriptor);
  905.    void* __somResult = 
  906.       SOM_ResolveD(this,ImplRepository,SOMObject,somDispatchA)
  907.     (this,methodId,descriptor,ap);
  908.    va_end(ap);
  909.    return __somResult;
  910. }
  911.  
  912.  
  913. /* va_list method: somDispatchD */
  914.  
  915. /*
  916.  *  Obsolete. Use somDispatch instead.
  917.  */
  918. /* the va_list invocation form */
  919. double   ImplRepository_somDispatchD(somId methodId, 
  920.         somId descriptor, 
  921.         va_list ap)
  922. {return SOM_ResolveD(this,ImplRepository,SOMObject,somDispatchD)
  923.     (this,methodId,descriptor,ap);
  924. }
  925.  
  926. /* the varargs invocation form */
  927. double   somDispatchD(somId methodId, 
  928.         somId descriptor, 
  929.         ...)
  930. {
  931. /*
  932.  *  Obsolete. Use somDispatch instead.
  933.  */
  934.    va_list ap;
  935.    va_start(ap, descriptor);
  936.    double __somResult = 
  937.       SOM_ResolveD(this,ImplRepository,SOMObject,somDispatchD)
  938.     (this,methodId,descriptor,ap);
  939.    va_end(ap);
  940.    return __somResult;
  941. }
  942.  
  943.  
  944. /* method: somPrintSelf */
  945. SOMObject*   somPrintSelf()
  946. {
  947. /*
  948.  *  Uses <SOMOutCharRoutine> to write a brief string with identifying
  949.  *  information about this object.  The default implementation just gives
  950.  *  the object's class name and its address in memory.
  951.  *  <self> is returned.
  952.  */
  953.    return SOM_ResolveD(this,ImplRepository,SOMObject,somPrintSelf)
  954.     (this);
  955. }
  956.  
  957.  
  958. /* method: somDumpSelf */
  959. void   somDumpSelf(long level)
  960. {
  961. /*
  962.  *  Uses <SOMOutCharRoutine> to write a detailed description of this object
  963.  *  and its current state.
  964.  * 
  965.  *  <level> indicates the nesting level for describing compound objects
  966.  *  it must be greater than or equal to zero.  All lines in the
  967.  *  description will be preceeded by <2*level> spaces.
  968.  * 
  969.  *  This routine only actually writes the data that concerns the object
  970.  *  as a whole, such as class, and uses <somDumpSelfInt> to describe
  971.  *  the object's current state.  This approach allows readable
  972.  *  descriptions of compound objects to be constructed.
  973.  * 
  974.  *  Generally it is not necessary to override this method, if it is
  975.  *  overriden it generally must be completely replaced.
  976.  */
  977.    SOM_ResolveD(this,ImplRepository,SOMObject,somDumpSelf)
  978.     (this,level);
  979. }
  980.  
  981.  
  982. /* method: somDumpSelfInt */
  983. void   somDumpSelfInt(long level)
  984. {
  985. /*
  986.  *  Uses <SOMOutCharRoutine> to write in the current state of this object.
  987.  *  Generally this method will need to be overridden.  When overriding
  988.  *  it, begin by calling the parent class form of this method and then
  989.  *  write in a description of your class's instance data. This will
  990.  *  result in a description of all the object's instance data going
  991.  *  from its root ancestor class to its specific class.
  992.  */
  993.    SOM_ResolveD(this,ImplRepository,SOMObject,somDumpSelfInt)
  994.     (this,level);
  995. }
  996.  
  997.  
  998.  
  999. };   /* ImplRepository */
  1000.  
  1001.  
  1002.  
  1003. #endif       /* SOM_ImplRepository_xh */
  1004.