home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / tolkit45.zip / os2tk45 / som / include / tdeq.xh < prev    next >
Text File  |  1999-02-22  |  41KB  |  1,355 lines
  1.  
  2. /*
  3.  * This file was generated by the SOM Compiler.
  4.  * FileName: tdeq.xh.
  5.  * Generated using:
  6.  *     SOM Precompiler somipc: 2.29.1.17
  7.  *     SOM Emitter emitxh: 2.47
  8.  */
  9.  
  10. /*
  11.  *    COMPONENT_NAME: somuc
  12.  * 
  13.  *    ORIGINS: 82, 81, 27
  14.  * 
  15.  * 
  16.  *     25H7912  (C)  COPYRIGHT International Business Machines Corp. 1992,1996,1996
  17.  *    All Rights Reserved
  18.  *    Licensed Materials - Property of IBM
  19.  *    US Government Users Restricted Rights - Use, duplication or
  20.  *    disclosure restricted by GSA ADP Schedule Contract with IBM Corp.
  21.  * 
  22.  *    Copyright ⌐ 1988, 1989 Apple Computer, Inc. All rights reserved.
  23.  * 
  24.  * CLASS_NAME: somf_TDeque
  25.  * 
  26.  * DESCRIPTION: A TDeque is a TSequence.  It is ordered based on the order
  27.  *              elements are added to, or removed from, the collection.
  28.  *              A TDeque can also be used as a queue, or a stack.
  29.  * 
  30.  */
  31.  
  32.  
  33. #ifndef SOM_somf_TDeque_xh
  34. #define SOM_somf_TDeque_xh
  35.  
  36. class somf_TDeque;
  37.  
  38. #define somf_TDeque_MajorVersion 2
  39. #define somf_TDeque_MinorVersion 1
  40.  
  41. /* C++ SOM defs */
  42. #include <somcls.xh>
  43. #include <somcm.xh>
  44.  
  45. /* C++ parent defs */
  46. #ifndef SOM_somf_TSequence_xh
  47. #include <tseq.xh>
  48. #endif
  49.  
  50. #ifndef somf_TDeque_API
  51. #define somf_TDeque_API
  52. /*
  53.  * -- The Class API
  54.  */
  55.  
  56. /*
  57.  * Start of bindings for IDL types
  58.  */
  59.  
  60. class SOMClass;
  61. class SOMObject;
  62. class somf_TIterator;
  63. class somf_TSequenceIterator;
  64. class somf_TDequeLinkable;
  65. class somf_TPrimitiveLinkedList;
  66.  
  67. /*
  68.  * End of bindings for IDL types.
  69.  */
  70.  
  71. /*
  72.  * Passthru lines: File: "C.xh", "after"
  73.  */
  74.  
  75. #include <mcollect.xh>
  76. #include <tseqitr.xh>
  77. #include <tdeqlink.xh>
  78.  
  79.  
  80. /* A procedure to create the somf_TDeque Class */
  81. SOMEXTERN SOMClass * SOMLINK somf_TDequeNewClass(
  82.         integer4 majorVersion,
  83.         integer4 minorVersion);
  84.  
  85. /* The API to the somf_TDeque class object, and the methods it introduces. */
  86. SOMEXTERN struct somf_TDequeClassDataStructure {
  87.     SOMClass *classObject;
  88.     somMToken somfAddAfter;
  89.     somMToken somfAddBefore;
  90.     somMToken somfAddLast;
  91.     somMToken somfAddFirst;
  92.     somMToken somfRemoveLast;
  93.     somMToken somfRemoveFirst;
  94.     somMToken somfCreateSequenceIterator;
  95.     somMToken somfRemoveQ;
  96.     somMToken somfInsert;
  97.     somMToken somfPop;
  98.     somMToken somfPush;
  99.     somMToken somfCreateNewLink;
  100.     somMToken somfAssign;
  101.     somMToken somfTDequeInitF;
  102.     somMToken somfTDequeInitD;
  103. } SOMDLINK somf_TDequeClassData;
  104. #define _somf_TDeque somf_TDequeClassData.classObject
  105.  
  106. /* The API to parentMtabs for somf_TDeque, and the instance data it introduces. */
  107. SOMEXTERN struct somf_TDequeCClassDataStructure {
  108.     somMethodTabs parentMtab;
  109.     somDToken              instanceDataToken;
  110. } SOMDLINK somf_TDequeCClassData;
  111.  
  112. /*
  113.  * -- Typedefs for somf_TDeque Method Procedures
  114.  */
  115. SOMEXTERN {
  116. typedef somf_TDeque*   SOMLINK somTP_somf_TDeque_somfTDequeInitF(somf_TDeque *somSelf, Environment *ev, 
  117.         somf_MCollectible_somf_MCollectibleCompareFn testfn);
  118. typedef somTP_somf_TDeque_somfTDequeInitF *somTD_somf_TDeque_somfTDequeInitF;
  119. typedef somf_TDeque*   SOMLINK somTP_somf_TDeque_somfTDequeInitD(somf_TDeque *somSelf, Environment *ev, 
  120.         somf_TDeque* s);
  121. typedef somTP_somf_TDeque_somfTDequeInitD *somTD_somf_TDeque_somfTDequeInitD;
  122. typedef void   SOMLINK somTP_somf_TDeque_somfAssign(somf_TDeque *somSelf, Environment *ev, 
  123.         somf_TDeque* s);
  124. typedef somTP_somf_TDeque_somfAssign *somTD_somf_TDeque_somfAssign;
  125. typedef void   SOMLINK somTP_somf_TDeque_somfAddAfter(somf_TDeque *somSelf, Environment *ev, 
  126.         somf_MCollectible* existingobj, 
  127.         somf_MCollectible* tobeadded);
  128. typedef somTP_somf_TDeque_somfAddAfter *somTD_somf_TDeque_somfAddAfter;
  129. typedef void   SOMLINK somTP_somf_TDeque_somfAddBefore(somf_TDeque *somSelf, Environment *ev, 
  130.         somf_MCollectible* existingobj, 
  131.         somf_MCollectible* tobeadded);
  132. typedef somTP_somf_TDeque_somfAddBefore *somTD_somf_TDeque_somfAddBefore;
  133. typedef void   SOMLINK somTP_somf_TDeque_somfAddLast(somf_TDeque *somSelf, Environment *ev, 
  134.         somf_MCollectible* obj);
  135. typedef somTP_somf_TDeque_somfAddLast *somTD_somf_TDeque_somfAddLast;
  136. typedef void   SOMLINK somTP_somf_TDeque_somfAddFirst(somf_TDeque *somSelf, Environment *ev, 
  137.         somf_MCollectible* obj);
  138. typedef somTP_somf_TDeque_somfAddFirst *somTD_somf_TDeque_somfAddFirst;
  139. typedef somf_MCollectible*   SOMLINK somTP_somf_TDeque_somfRemoveLast(somf_TDeque *somSelf, Environment *ev);
  140. typedef somTP_somf_TDeque_somfRemoveLast *somTD_somf_TDeque_somfRemoveLast;
  141. typedef somf_MCollectible*   SOMLINK somTP_somf_TDeque_somfRemoveFirst(somf_TDeque *somSelf, Environment *ev);
  142. typedef somTP_somf_TDeque_somfRemoveFirst *somTD_somf_TDeque_somfRemoveFirst;
  143. typedef somf_TSequenceIterator*   SOMLINK somTP_somf_TDeque_somfCreateSequenceIterator(somf_TDeque *somSelf, Environment *ev);
  144. typedef somTP_somf_TDeque_somfCreateSequenceIterator *somTD_somf_TDeque_somfCreateSequenceIterator;
  145. typedef somf_MCollectible*   SOMLINK somTP_somf_TDeque_somfRemoveQ(somf_TDeque *somSelf, Environment *ev);
  146. typedef somTP_somf_TDeque_somfRemoveQ *somTD_somf_TDeque_somfRemoveQ;
  147. typedef void   SOMLINK somTP_somf_TDeque_somfInsert(somf_TDeque *somSelf, Environment *ev, 
  148.         somf_MCollectible* obj);
  149. typedef somTP_somf_TDeque_somfInsert *somTD_somf_TDeque_somfInsert;
  150. typedef somf_MCollectible*   SOMLINK somTP_somf_TDeque_somfPop(somf_TDeque *somSelf, Environment *ev);
  151. typedef somTP_somf_TDeque_somfPop *somTD_somf_TDeque_somfPop;
  152. typedef void   SOMLINK somTP_somf_TDeque_somfPush(somf_TDeque *somSelf, Environment *ev, 
  153.         somf_MCollectible* obj);
  154. typedef somTP_somf_TDeque_somfPush *somTD_somf_TDeque_somfPush;
  155. typedef somf_TDequeLinkable*   SOMLINK somTP_somf_TDeque_somfCreateNewLink(somf_TDeque *somSelf, Environment *ev, 
  156.         somf_TDequeLinkable* p, 
  157.         somf_TDequeLinkable* n, 
  158.         somf_MCollectible* v);
  159. typedef somTP_somf_TDeque_somfCreateNewLink *somTD_somf_TDeque_somfCreateNewLink;
  160.  
  161. /*
  162.  * -- Typedefs for Reintroduced Wrapper Methods
  163.  */
  164. typedef somf_MCollectible*   SOMLINK somTP_somf_TDeque_somfAfter(somf_TDeque *somSelf, Environment *ev, 
  165.         somf_MCollectible* obj);
  166. typedef somTP_somf_TDeque_somfAfter *somTD_somf_TDeque_somfAfter;
  167. typedef somf_MCollectible*   SOMLINK somTP_somf_TDeque_somfBefore(somf_TDeque *somSelf, Environment *ev, 
  168.         somf_MCollectible* obj);
  169. typedef somTP_somf_TDeque_somfBefore *somTD_somf_TDeque_somfBefore;
  170. typedef somf_MCollectible*   SOMLINK somTP_somf_TDeque_somfLast(somf_TDeque *somSelf, Environment *ev);
  171. typedef somTP_somf_TDeque_somfLast *somTD_somf_TDeque_somfLast;
  172. typedef somf_MCollectible*   SOMLINK somTP_somf_TDeque_somfFirst(somf_TDeque *somSelf, Environment *ev);
  173. typedef somTP_somf_TDeque_somfFirst *somTD_somf_TDeque_somfFirst;
  174. typedef long   SOMLINK somTP_somf_TDeque_somfOccurrencesOf(somf_TDeque *somSelf, Environment *ev, 
  175.         somf_MCollectible* obj);
  176. typedef somTP_somf_TDeque_somfOccurrencesOf *somTD_somf_TDeque_somfOccurrencesOf;
  177. typedef somf_TSequence*   SOMLINK somTP_somf_TDeque_somfTSequenceInit(somf_TDeque *somSelf, Environment *ev, 
  178.         somf_MCollectible_somf_MCollectibleCompareFn testfn);
  179. typedef somTP_somf_TDeque_somfTSequenceInit *somTD_somf_TDeque_somfTSequenceInit;
  180. typedef somf_MCollectible*   SOMLINK somTP_somf_TDeque_somfAdd(somf_TDeque *somSelf, Environment *ev, 
  181.         somf_MCollectible* obj);
  182. typedef somTP_somf_TDeque_somfAdd *somTD_somf_TDeque_somfAdd;
  183. typedef somf_MCollectible*   SOMLINK somTP_somf_TDeque_somfRemove(somf_TDeque *somSelf, Environment *ev, 
  184.         somf_MCollectible* obj);
  185. typedef somTP_somf_TDeque_somfRemove *somTD_somf_TDeque_somfRemove;
  186. typedef void   SOMLINK somTP_somf_TDeque_somfRemoveAll(somf_TDeque *somSelf, Environment *ev);
  187. typedef somTP_somf_TDeque_somfRemoveAll *somTD_somf_TDeque_somfRemoveAll;
  188. typedef void   SOMLINK somTP_somf_TDeque_somfDeleteAll(somf_TDeque *somSelf, Environment *ev);
  189. typedef somTP_somf_TDeque_somfDeleteAll *somTD_somf_TDeque_somfDeleteAll;
  190. typedef long   SOMLINK somTP_somf_TDeque_somfCount(somf_TDeque *somSelf, Environment *ev);
  191. typedef somTP_somf_TDeque_somfCount *somTD_somf_TDeque_somfCount;
  192. typedef somf_TIterator*   SOMLINK somTP_somf_TDeque_somfCreateIterator(somf_TDeque *somSelf, Environment *ev);
  193. typedef somTP_somf_TDeque_somfCreateIterator *somTD_somf_TDeque_somfCreateIterator;
  194. typedef void   SOMLINK somTP_somf_TDeque_somInit(somf_TDeque *somSelf);
  195. typedef somTP_somf_TDeque_somInit *somTD_somf_TDeque_somInit;
  196. typedef void   SOMLINK somTP_somf_TDeque_somfAddAll(somf_TDeque *somSelf, Environment *ev, 
  197.         somf_TCollection* col);
  198. typedef somTP_somf_TDeque_somfAddAll *somTD_somf_TDeque_somfAddAll;
  199. typedef somf_MCollectible*   SOMLINK somTP_somf_TDeque_somfMember(somf_TDeque *somSelf, Environment *ev, 
  200.         somf_MCollectible* obj);
  201. typedef somTP_somf_TDeque_somfMember *somTD_somf_TDeque_somfMember;
  202. typedef somf_MCollectible_somf_MCollectibleCompareFn   SOMLINK somTP_somf_TDeque_somfTestFunction(somf_TDeque *somSelf, Environment *ev);
  203. typedef somTP_somf_TDeque_somfTestFunction *somTD_somf_TDeque_somfTestFunction;
  204. typedef void   SOMLINK somTP_somf_TDeque_somfSetTestFunction(somf_TDeque *somSelf, Environment *ev, 
  205.         somf_MCollectible_somf_MCollectibleCompareFn testfn);
  206. typedef somTP_somf_TDeque_somfSetTestFunction *somTD_somf_TDeque_somfSetTestFunction;
  207. typedef somf_TCollection*   SOMLINK somTP_somf_TDeque_somfTCollectionInit(somf_TDeque *somSelf, Environment *ev, 
  208.         somf_MCollectible_somf_MCollectibleCompareFn testfn);
  209. typedef somTP_somf_TDeque_somfTCollectionInit *somTD_somf_TDeque_somfTCollectionInit;
  210. typedef boolean   SOMLINK somTP_somf_TDeque_somfIsEqual(somf_TDeque *somSelf, Environment *ev, 
  211.         somf_MCollectible* obj);
  212. typedef somTP_somf_TDeque_somfIsEqual *somTD_somf_TDeque_somfIsEqual;
  213. typedef somf_MCollectible*   SOMLINK somTP_somf_TDeque_somfClone(somf_TDeque *somSelf, Environment *ev);
  214. typedef somTP_somf_TDeque_somfClone *somTD_somf_TDeque_somfClone;
  215. typedef somf_MCollectible*   SOMLINK somTP_somf_TDeque_somfClonePointer(somf_TDeque *somSelf, Environment *ev, 
  216.         somf_MCollectible* clonee);
  217. typedef somTP_somf_TDeque_somfClonePointer *somTD_somf_TDeque_somfClonePointer;
  218. typedef long   SOMLINK somTP_somf_TDeque_somfHash(somf_TDeque *somSelf, Environment *ev);
  219. typedef somTP_somf_TDeque_somfHash *somTD_somf_TDeque_somfHash;
  220. typedef boolean   SOMLINK somTP_somf_TDeque_somfIsSame(somf_TDeque *somSelf, Environment *ev, 
  221.         somf_MCollectible* obj);
  222. typedef somTP_somf_TDeque_somfIsSame *somTD_somf_TDeque_somfIsSame;
  223. typedef boolean   SOMLINK somTP_somf_TDeque_somfIsNotEqual(somf_TDeque *somSelf, Environment *ev, 
  224.         somf_MCollectible* obj);
  225. typedef somTP_somf_TDeque_somfIsNotEqual *somTD_somf_TDeque_somfIsNotEqual;
  226. typedef void   SOMLINK somTP_somf_TDeque_somDefaultInit(somf_TDeque *somSelf, 
  227.         som3InitCtrl* ctrl);
  228. typedef somTP_somf_TDeque_somDefaultInit *somTD_somf_TDeque_somDefaultInit;
  229. typedef void   SOMLINK somTP_somf_TDeque_somDestruct(somf_TDeque *somSelf, 
  230.         octet doFree, 
  231.         som3DestructCtrl* ctrl);
  232. typedef somTP_somf_TDeque_somDestruct *somTD_somf_TDeque_somDestruct;
  233. typedef void   SOMLINK somTP_somf_TDeque_somDefaultCopyInit(somf_TDeque *somSelf, 
  234.         som3InitCtrl* ctrl, 
  235.         SOMObject* fromObj);
  236. typedef somTP_somf_TDeque_somDefaultCopyInit *somTD_somf_TDeque_somDefaultCopyInit;
  237. typedef somf_TDeque*   SOMLINK somTP_somf_TDeque_somDefaultAssign(somf_TDeque *somSelf, 
  238.         som3AssignCtrl* ctrl, 
  239.         SOMObject* fromObj);
  240. typedef somTP_somf_TDeque_somDefaultAssign *somTD_somf_TDeque_somDefaultAssign;
  241. typedef void   SOMLINK somTP_somf_TDeque_somDefaultConstCopyInit(somf_TDeque *somSelf, 
  242.         som3InitCtrl* ctrl, 
  243.         SOMObject* fromObj);
  244. typedef somTP_somf_TDeque_somDefaultConstCopyInit *somTD_somf_TDeque_somDefaultConstCopyInit;
  245. typedef void   SOMLINK somTP_somf_TDeque_somDefaultVCopyInit(somf_TDeque *somSelf, 
  246.         som3InitCtrl* ctrl, 
  247.         SOMObject* fromObj);
  248. typedef somTP_somf_TDeque_somDefaultVCopyInit *somTD_somf_TDeque_somDefaultVCopyInit;
  249. typedef void   SOMLINK somTP_somf_TDeque_somDefaultConstVCopyInit(somf_TDeque *somSelf, 
  250.         som3InitCtrl* ctrl, 
  251.         SOMObject* fromObj);
  252. typedef somTP_somf_TDeque_somDefaultConstVCopyInit *somTD_somf_TDeque_somDefaultConstVCopyInit;
  253. typedef somf_TDeque*   SOMLINK somTP_somf_TDeque_somDefaultConstAssign(somf_TDeque *somSelf, 
  254.         som3AssignCtrl* ctrl, 
  255.         SOMObject* fromObj);
  256. typedef somTP_somf_TDeque_somDefaultConstAssign *somTD_somf_TDeque_somDefaultConstAssign;
  257. typedef somf_TDeque*   SOMLINK somTP_somf_TDeque_somDefaultVAssign(somf_TDeque *somSelf, 
  258.         som3AssignCtrl* ctrl, 
  259.         SOMObject* fromObj);
  260. typedef somTP_somf_TDeque_somDefaultVAssign *somTD_somf_TDeque_somDefaultVAssign;
  261. typedef somf_TDeque*   SOMLINK somTP_somf_TDeque_somDefaultConstVAssign(somf_TDeque *somSelf, 
  262.         som3AssignCtrl* ctrl, 
  263.         SOMObject* fromObj);
  264. typedef somTP_somf_TDeque_somDefaultConstVAssign *somTD_somf_TDeque_somDefaultConstVAssign;
  265. typedef void   SOMLINK somTP_somf_TDeque_somFree(somf_TDeque *somSelf);
  266. typedef somTP_somf_TDeque_somFree *somTD_somf_TDeque_somFree;
  267. typedef void   SOMLINK somTP_somf_TDeque_somUninit(somf_TDeque *somSelf);
  268. typedef somTP_somf_TDeque_somUninit *somTD_somf_TDeque_somUninit;
  269. typedef SOMClass*   SOMLINK somTP_somf_TDeque_somGetClass(somf_TDeque *somSelf);
  270. typedef somTP_somf_TDeque_somGetClass *somTD_somf_TDeque_somGetClass;
  271. typedef string   SOMLINK somTP_somf_TDeque_somGetClassName(somf_TDeque *somSelf);
  272. typedef somTP_somf_TDeque_somGetClassName *somTD_somf_TDeque_somGetClassName;
  273. typedef long   SOMLINK somTP_somf_TDeque_somGetSize(somf_TDeque *somSelf);
  274. typedef somTP_somf_TDeque_somGetSize *somTD_somf_TDeque_somGetSize;
  275. typedef boolean   SOMLINK somTP_somf_TDeque_somIsA(somf_TDeque *somSelf, 
  276.         SOMClass* aClassObj);
  277. typedef somTP_somf_TDeque_somIsA *somTD_somf_TDeque_somIsA;
  278. typedef boolean   SOMLINK somTP_somf_TDeque_somIsInstanceOf(somf_TDeque *somSelf, 
  279.         SOMClass* aClassObj);
  280. typedef somTP_somf_TDeque_somIsInstanceOf *somTD_somf_TDeque_somIsInstanceOf;
  281. typedef boolean   SOMLINK somTP_somf_TDeque_somRespondsTo(somf_TDeque *somSelf, 
  282.         somId mId);
  283. typedef somTP_somf_TDeque_somRespondsTo *somTD_somf_TDeque_somRespondsTo;
  284. typedef boolean   SOMLINK somTP_somf_TDeque_somDispatch(somf_TDeque *somSelf, 
  285.         somToken* retValue, 
  286.         somId methodId, 
  287.         va_list ap);
  288. typedef somTP_somf_TDeque_somDispatch *somTD_somf_TDeque_somDispatch;
  289. typedef boolean   SOMLINK somTP_somf_TDeque_somClassDispatch(somf_TDeque *somSelf, 
  290.         SOMClass* clsObj, 
  291.         somToken* retValue, 
  292.         somId methodId, 
  293.         va_list ap);
  294. typedef somTP_somf_TDeque_somClassDispatch *somTD_somf_TDeque_somClassDispatch;
  295. typedef boolean   SOMLINK somTP_somf_TDeque_somCastObj(somf_TDeque *somSelf, 
  296.         SOMClass* cls);
  297. typedef somTP_somf_TDeque_somCastObj *somTD_somf_TDeque_somCastObj;
  298. typedef boolean   SOMLINK somTP_somf_TDeque_somResetObj(somf_TDeque *somSelf);
  299. typedef somTP_somf_TDeque_somResetObj *somTD_somf_TDeque_somResetObj;
  300. typedef void   SOMLINK somTP_somf_TDeque_somDispatchV(somf_TDeque *somSelf, 
  301.         somId methodId, 
  302.         somId descriptor, 
  303.         va_list ap);
  304. typedef somTP_somf_TDeque_somDispatchV *somTD_somf_TDeque_somDispatchV;
  305. typedef long   SOMLINK somTP_somf_TDeque_somDispatchL(somf_TDeque *somSelf, 
  306.         somId methodId, 
  307.         somId descriptor, 
  308.         va_list ap);
  309. typedef somTP_somf_TDeque_somDispatchL *somTD_somf_TDeque_somDispatchL;
  310. typedef void*   SOMLINK somTP_somf_TDeque_somDispatchA(somf_TDeque *somSelf, 
  311.         somId methodId, 
  312.         somId descriptor, 
  313.         va_list ap);
  314. typedef somTP_somf_TDeque_somDispatchA *somTD_somf_TDeque_somDispatchA;
  315. typedef double   SOMLINK somTP_somf_TDeque_somDispatchD(somf_TDeque *somSelf, 
  316.         somId methodId, 
  317.         somId descriptor, 
  318.         va_list ap);
  319. typedef somTP_somf_TDeque_somDispatchD *somTD_somf_TDeque_somDispatchD;
  320. typedef SOMObject*   SOMLINK somTP_somf_TDeque_somPrintSelf(somf_TDeque *somSelf);
  321. typedef somTP_somf_TDeque_somPrintSelf *somTD_somf_TDeque_somPrintSelf;
  322. typedef void   SOMLINK somTP_somf_TDeque_somDumpSelf(somf_TDeque *somSelf, 
  323.         long level);
  324. typedef somTP_somf_TDeque_somDumpSelf *somTD_somf_TDeque_somDumpSelf;
  325. typedef void   SOMLINK somTP_somf_TDeque_somDumpSelfInt(somf_TDeque *somSelf, 
  326.         long level);
  327. typedef somTP_somf_TDeque_somDumpSelfInt *somTD_somf_TDeque_somDumpSelfInt;
  328. }
  329.  
  330. #endif /* somf_TDeque_API */
  331.  
  332.  
  333. /*
  334.  * -- This emitter treats Method Tokens as Thunks by default.
  335.  * -- Use the sc modifier "nothunks" to change this default
  336.  */
  337. #undef somresolve_
  338. #define somresolve_(obj,mToken) ((somMethodProc*)((void)obj, mToken))
  339.  
  340. /*
  341.  * -- The C++ Wrapper Class for somf_TDeque
  342.  */
  343. class somf_TDeque : public somf_TSequence
  344. {
  345. public:
  346.  
  347. // somf_TDeque::new creates the class object if necessary, and then uses somNewNoInit
  348. // to allocate memory and create the object. Initialization is in ctors.
  349. void *operator new(size_t)
  350. {
  351.    if (!_somf_TDeque) somf_TDequeNewClass(somf_TDeque_MajorVersion,somf_TDeque_MinorVersion);
  352.    return (void*)
  353.       SOM_Resolve(_somf_TDeque,SOMClass,somNewNoInit)
  354.          ((SOMClass *)((void*)_somf_TDeque));
  355. }
  356.  
  357. // somf_TDeque::delete uses somDestruct.
  358. void operator delete(void * obj)
  359. {
  360.    if (obj && *(void**)obj) {
  361.       SOM_Resolve(obj,SOMObject,somFree)
  362.          ((SOMObject*)obj);
  363.    }
  364. }
  365.  
  366. somf_TDeque& operator=(somf_TDeque& fromObj)
  367. {
  368.    this->somDefaultAssign(0,(SOMObject*)((void*)&fromObj));
  369.    return *this;
  370. }
  371.  
  372. somf_TDeque()
  373. {
  374.    if (*(void**)this != 
  375.        ((somParentMtabStructPtr)
  376.         (somf_TDequeCClassData.parentMtab))->mtab)
  377.       return;
  378.    ((SOMObject*)((void*)this))->somDefaultInit(0);
  379. }
  380.  
  381. somf_TDeque(somf_TDeque* fromObj)
  382. {
  383.    if (*(void**)this != 
  384.        ((somParentMtabStructPtr)
  385.         (somf_TDequeCClassData.parentMtab))->mtab)
  386.       return;
  387.    ((SOMObject*)((void*)this))->somDefaultCopyInit(0,((SOMObject*)((void*)fromObj)));
  388. }
  389.  
  390. #ifdef __IBMCPP__
  391. #pragma info(nocnv,nopar)
  392. #endif
  393. somf_TDeque(const somf_TDeque* fromObj)
  394. {
  395.    if (*(void**)this != 
  396.        ((somParentMtabStructPtr)
  397.         (somf_TDequeCClassData.parentMtab))->mtab)
  398.       return;
  399.    ((SOMObject*)((void*)this))->somDefaultConstCopyInit(0,((SOMObject*)((void*)fromObj)));
  400. }
  401. #ifdef __IBMCPP__
  402. #pragma info(restore)
  403. #endif
  404.  
  405.  
  406. /* method: somfTDequeInitF */
  407. somf_TDeque*   somfTDequeInitF(Environment *ev, 
  408.         somf_MCollectible_somf_MCollectibleCompareFn testfn)
  409. {
  410. /*
  411.  *  Initializes the new deque.
  412.  */
  413.    return SOM_ResolveD(this,somf_TDeque,somf_TDeque,somfTDequeInitF)
  414.     (this, ev,testfn);
  415. }
  416.  
  417.  
  418. /* method: somfTDequeInitD */
  419. somf_TDeque*   somfTDequeInitD(Environment *ev, 
  420.         somf_TDeque* s)
  421. {
  422. /*
  423.  *  Initializes the new deque.
  424.  */
  425.    return SOM_ResolveD(this,somf_TDeque,somf_TDeque,somfTDequeInitD)
  426.     (this, ev,s);
  427. }
  428.  
  429.  
  430. /* method: somfAssign */
  431. void   somfAssign(Environment *ev, 
  432.         somf_TDeque* s)
  433. {
  434. /*
  435.  *  Assign the instance of this equal to the instance of source.
  436.  */
  437.    SOM_ResolveD(this,somf_TDeque,somf_TDeque,somfAssign)
  438.     (this, ev,s);
  439. }
  440.  
  441.  
  442. /* method: somfAddAfter */
  443. void   somfAddAfter(Environment *ev, 
  444.         somf_MCollectible* existingobj, 
  445.         somf_MCollectible* tobeadded)
  446. {
  447. /*
  448.  *  Add the obj object into the List after the existing object.
  449.  */
  450.    SOM_ResolveD(this,somf_TDeque,somf_TDeque,somfAddAfter)
  451.     (this, ev,existingobj,tobeadded);
  452. }
  453.  
  454.  
  455. /* method: somfAddBefore */
  456. void   somfAddBefore(Environment *ev, 
  457.         somf_MCollectible* existingobj, 
  458.         somf_MCollectible* tobeadded)
  459. {
  460. /*
  461.  *  Add the obj object into the List before the existing object.
  462.  */
  463.    SOM_ResolveD(this,somf_TDeque,somf_TDeque,somfAddBefore)
  464.     (this, ev,existingobj,tobeadded);
  465. }
  466.  
  467.  
  468. /* method: somfAddLast */
  469. void   somfAddLast(Environment *ev, 
  470.         somf_MCollectible* obj)
  471. {
  472. /*
  473.  *  Add the obj object as the last object in the List.
  474.  */
  475.    SOM_ResolveD(this,somf_TDeque,somf_TDeque,somfAddLast)
  476.     (this, ev,obj);
  477. }
  478.  
  479.  
  480. /* method: somfAddFirst */
  481. void   somfAddFirst(Environment *ev, 
  482.         somf_MCollectible* obj)
  483. {
  484. /*
  485.  *  Add the obj object as the first object in the List.
  486.  */
  487.    SOM_ResolveD(this,somf_TDeque,somf_TDeque,somfAddFirst)
  488.     (this, ev,obj);
  489. }
  490.  
  491.  
  492. /* method: somfRemoveLast */
  493. somf_MCollectible*   somfRemoveLast(Environment *ev)
  494. {
  495. /*
  496.  *  Remove the last object in the List.
  497.  */
  498.    return SOM_ResolveD(this,somf_TDeque,somf_TDeque,somfRemoveLast)
  499.     (this, ev);
  500. }
  501.  
  502.  
  503. /* method: somfRemoveFirst */
  504. somf_MCollectible*   somfRemoveFirst(Environment *ev)
  505. {
  506. /*
  507.  *  Remove the first object in the deque.
  508.  */
  509.    return SOM_ResolveD(this,somf_TDeque,somf_TDeque,somfRemoveFirst)
  510.     (this, ev);
  511. }
  512.  
  513.  
  514. /* method: somfCreateSequenceIterator */
  515. somf_TSequenceIterator*   somfCreateSequenceIterator(Environment *ev)
  516. {
  517. /*
  518.  *  This method returns a new iterator which is suitable for use in iterating
  519.  *  over the objects in this collection.
  520.  */
  521.    return SOM_ResolveD(this,somf_TDeque,somf_TDeque,somfCreateSequenceIterator)
  522.     (this, ev);
  523. }
  524.  
  525.  
  526. /* method: somfRemoveQ */
  527. somf_MCollectible*   somfRemoveQ(Environment *ev)
  528. {
  529. /*
  530.  *  Remove the object on the deque/queue
  531.  *  (This call can be used to simulate a queue)
  532.  */
  533.    return SOM_ResolveD(this,somf_TDeque,somf_TDeque,somfRemoveQ)
  534.     (this, ev);
  535. }
  536.  
  537.  
  538. /* method: somfInsert */
  539. void   somfInsert(Environment *ev, 
  540.         somf_MCollectible* obj)
  541. {
  542. /*
  543.  *  Add the object to the deque/queue
  544.  *  (This call can be used to simulate a queue)
  545.  */
  546.    SOM_ResolveD(this,somf_TDeque,somf_TDeque,somfInsert)
  547.     (this, ev,obj);
  548. }
  549.  
  550.  
  551. /* method: somfPop */
  552. somf_MCollectible*   somfPop(Environment *ev)
  553. {
  554. /*
  555.  *  Remove the object on the top of the deque/stack
  556.  *  (This call can be used to simulate a stack)
  557.  */
  558.    return SOM_ResolveD(this,somf_TDeque,somf_TDeque,somfPop)
  559.     (this, ev);
  560. }
  561.  
  562.  
  563. /* method: somfPush */
  564. void   somfPush(Environment *ev, 
  565.         somf_MCollectible* obj)
  566. {
  567. /*
  568.  *  Add the object to the top of the deque/stack
  569.  *  (This call can be used to simulate a stack)
  570.  */
  571.    SOM_ResolveD(this,somf_TDeque,somf_TDeque,somfPush)
  572.     (this, ev,obj);
  573. }
  574.  
  575.  
  576. /* method: somfCreateNewLink */
  577. somf_TDequeLinkable*   somfCreateNewLink(Environment *ev, 
  578.         somf_TDequeLinkable* p, 
  579.         somf_TDequeLinkable* n, 
  580.         somf_MCollectible* v)
  581. {
  582. /*
  583.  *  Create a new TDeque link, using a TDequeLinkable instance.
  584.  */
  585.    return SOM_ResolveD(this,somf_TDeque,somf_TDeque,somfCreateNewLink)
  586.     (this, ev,p,n,v);
  587. }
  588.  
  589.  
  590. /*
  591.  * Reintroduce inherited methods
  592.  */
  593.  
  594. /* method: somfAfter */
  595. somf_MCollectible*   somfAfter(Environment *ev, 
  596.         somf_MCollectible* obj)
  597. {
  598. /*
  599.  *  Return the object found after obj.
  600.  */
  601.    return SOM_ResolveD(this,somf_TDeque,somf_TSequence,somfAfter)
  602.     (this, ev,obj);
  603. }
  604.  
  605.  
  606. /* method: somfBefore */
  607. somf_MCollectible*   somfBefore(Environment *ev, 
  608.         somf_MCollectible* obj)
  609. {
  610. /*
  611.  *  Return the object found before obj.
  612.  */
  613.    return SOM_ResolveD(this,somf_TDeque,somf_TSequence,somfBefore)
  614.     (this, ev,obj);
  615. }
  616.  
  617.  
  618. /* method: somfLast */
  619. somf_MCollectible*   somfLast(Environment *ev)
  620. {
  621. /*
  622.  *  Determine the last object in this.
  623.  */
  624.    return SOM_ResolveD(this,somf_TDeque,somf_TSequence,somfLast)
  625.     (this, ev);
  626. }
  627.  
  628.  
  629. /* method: somfFirst */
  630. somf_MCollectible*   somfFirst(Environment *ev)
  631. {
  632. /*
  633.  *  Determine the first object in this.
  634.  */
  635.    return SOM_ResolveD(this,somf_TDeque,somf_TSequence,somfFirst)
  636.     (this, ev);
  637. }
  638.  
  639.  
  640. /* method: somfOccurrencesOf */
  641. long   somfOccurrencesOf(Environment *ev, 
  642.         somf_MCollectible* obj)
  643. {
  644. /*
  645.  *  Determine the number of times obj is in this.
  646.  */
  647.    return SOM_ResolveD(this,somf_TDeque,somf_TSequence,somfOccurrencesOf)
  648.     (this, ev,obj);
  649. }
  650.  
  651.  
  652. /* method: somfTSequenceInit */
  653. somf_TSequence*   somfTSequenceInit(Environment *ev, 
  654.         somf_MCollectible_somf_MCollectibleCompareFn testfn)
  655. {
  656. /*
  657.  *  This method initializes a new TSequence.
  658.  */
  659.    return SOM_ResolveD(this,somf_TDeque,somf_TSequence,somfTSequenceInit)
  660.     (this, ev,testfn);
  661. }
  662.  
  663.  
  664. /* method: somfAdd */
  665. somf_MCollectible*   somfAdd(Environment *ev, 
  666.         somf_MCollectible* obj)
  667. {
  668.    return SOM_ResolveD(this,somf_TDeque,somf_TCollection,somfAdd)
  669.     (this, ev,obj);
  670. }
  671.  
  672.  
  673. /* method: somfRemove */
  674. somf_MCollectible*   somfRemove(Environment *ev, 
  675.         somf_MCollectible* obj)
  676. {
  677.    return SOM_ResolveD(this,somf_TDeque,somf_TCollection,somfRemove)
  678.     (this, ev,obj);
  679. }
  680.  
  681.  
  682. /* method: somfRemoveAll */
  683. void   somfRemoveAll(Environment *ev)
  684. {
  685.    SOM_ResolveD(this,somf_TDeque,somf_TCollection,somfRemoveAll)
  686.     (this, ev);
  687. }
  688.  
  689.  
  690. /* method: somfDeleteAll */
  691. void   somfDeleteAll(Environment *ev)
  692. {
  693.    SOM_ResolveD(this,somf_TDeque,somf_TCollection,somfDeleteAll)
  694.     (this, ev);
  695. }
  696.  
  697.  
  698. /* method: somfCount */
  699. long   somfCount(Environment *ev)
  700. {
  701.    return SOM_ResolveD(this,somf_TDeque,somf_TCollection,somfCount)
  702.     (this, ev);
  703. }
  704.  
  705.  
  706. /* method: somfCreateIterator */
  707. somf_TIterator*   somfCreateIterator(Environment *ev)
  708. {
  709.    return SOM_ResolveD(this,somf_TDeque,somf_TCollection,somfCreateIterator)
  710.     (this, ev);
  711. }
  712.  
  713.  
  714. /* method: somInit */
  715. void   somInit()
  716. {
  717.    SOM_ResolveD(this,somf_TDeque,SOMObject,somInit)
  718.     (this);
  719. }
  720.  
  721.  
  722. /* method: somfAddAll */
  723. void   somfAddAll(Environment *ev, 
  724.         somf_TCollection* col)
  725. {
  726. /*
  727.  *  Add all of the objects in collection to this.  Essentially this is
  728.  *  equivalent to getting an iterator for the collection passed in and adding
  729.  *  each element in the collection to this.
  730.  */
  731.    SOM_ResolveD(this,somf_TDeque,somf_TCollection,somfAddAll)
  732.     (this, ev,col);
  733. }
  734.  
  735.  
  736. /* method: somfMember */
  737. somf_MCollectible*   somfMember(Environment *ev, 
  738.         somf_MCollectible* obj)
  739. {
  740. /*
  741.  *  Each object in this is compared to obj using the function testFn.  Return the
  742.  *  object for which testFn returned TRUE.  Return SOMF_NIL if not object was found.
  743.  */
  744.    return SOM_ResolveD(this,somf_TDeque,somf_TCollection,somfMember)
  745.     (this, ev,obj);
  746. }
  747.  
  748.  
  749. /* method: somfTestFunction */
  750. somf_MCollectible_somf_MCollectibleCompareFn   somfTestFunction(Environment *ev)
  751. {
  752. /*
  753.  *  Return the test function.  This is usually either IsSame or IsEqual.
  754.  */
  755.    return SOM_ResolveD(this,somf_TDeque,somf_TCollection,somfTestFunction)
  756.     (this, ev);
  757. }
  758.  
  759.  
  760. /* method: somfSetTestFunction */
  761. void   somfSetTestFunction(Environment *ev, 
  762.         somf_MCollectible_somf_MCollectibleCompareFn testfn)
  763. {
  764. /*
  765.  *  Set the test function.
  766.  */
  767.    SOM_ResolveD(this,somf_TDeque,somf_TCollection,somfSetTestFunction)
  768.     (this, ev,testfn);
  769. }
  770.  
  771.  
  772. /* method: somfTCollectionInit */
  773. somf_TCollection*   somfTCollectionInit(Environment *ev, 
  774.         somf_MCollectible_somf_MCollectibleCompareFn testfn)
  775. {
  776. /*
  777.  *  Initialize the somf_TCollection test function to testfn.
  778.  */
  779.    return SOM_ResolveD(this,somf_TDeque,somf_TCollection,somfTCollectionInit)
  780.     (this, ev,testfn);
  781. }
  782.  
  783.  
  784. /* method: somfIsEqual */
  785. boolean   somfIsEqual(Environment *ev, 
  786.         somf_MCollectible* obj)
  787. {
  788.    return SOM_ResolveD(this,somf_TDeque,somf_MCollectible,somfIsEqual)
  789.     (this, ev,obj);
  790. }
  791.  
  792.  
  793. /* method: somfClone */
  794. somf_MCollectible*   somfClone(Environment *ev)
  795. {
  796. /*
  797.  *  somfClone provides a general function for creating a new instance of this.
  798.  */
  799.    return SOM_ResolveD(this,somf_TDeque,somf_MCollectible,somfClone)
  800.     (this, ev);
  801. }
  802.  
  803.  
  804. /* method: somfClonePointer */
  805. somf_MCollectible*   somfClonePointer(Environment *ev, 
  806.         somf_MCollectible* clonee)
  807. {
  808. /*
  809.  *  somfClonePointer returns a pointer to a Clone
  810.  */
  811.    return SOM_ResolveD(this,somf_TDeque,somf_MCollectible,somfClonePointer)
  812.     (this, ev,clonee);
  813. }
  814.  
  815.  
  816. /* method: somfHash */
  817. long   somfHash(Environment *ev)
  818. {
  819. /*
  820.  *  somfHash returns a value suitable for use as a hashing probe for this.
  821.  *  The default function will simply return the address of the object.
  822.  *  The default function is almost certainly not adequate if you are overriding
  823.  *  somfIsEqual because you need to make sure that all objects that "are equal"
  824.  *  to each other return the same hash value.  For example, a TText object would
  825.  *  return a hash value computed using the characters in the string instead of
  826.  *  the address of the string.
  827.  */
  828.    return SOM_ResolveD(this,somf_TDeque,somf_MCollectible,somfHash)
  829.     (this, ev);
  830. }
  831.  
  832.  
  833. /* method: somfIsSame */
  834. boolean   somfIsSame(Environment *ev, 
  835.         somf_MCollectible* obj)
  836. {
  837. /*
  838.  *  The default function for somfIsSame is a pointer comparison
  839.  */
  840.    return SOM_ResolveD(this,somf_TDeque,somf_MCollectible,somfIsSame)
  841.     (this, ev,obj);
  842. }
  843.  
  844.  
  845. /* method: somfIsNotEqual */
  846. boolean   somfIsNotEqual(Environment *ev, 
  847.         somf_MCollectible* obj)
  848. {
  849. /*
  850.  *  somfIsNotEqual returns TRUE if obj is NOT isomorphic to this.  It uses
  851.  *  somfIsEqual, so overriding somfIsEqual will handle the logic of somfIsNotEqual too.
  852.  */
  853.    return SOM_ResolveD(this,somf_TDeque,somf_MCollectible,somfIsNotEqual)
  854.     (this, ev,obj);
  855. }
  856.  
  857.  
  858. /* initializer method: somDefaultInit */
  859. void   somDefaultInit(som3InitCtrl* ctrl)
  860. {
  861. /*
  862.  *  A default initializer for a SOM object. Passing a null ctrl
  863.  *  indicates to the receiver that its class is the class of the
  864.  *  object being initialized, whereby the initializer will determine
  865.  *  an appropriate control structure.
  866.  */
  867.    SOM_ResolveD(this,somf_TDeque,SOMObject,somDefaultInit)
  868.     (this,ctrl);
  869. }
  870.  
  871.  
  872. /* method: somDestruct */
  873. void   somDestruct(octet doFree, 
  874.         som3DestructCtrl* ctrl)
  875. {
  876. /*
  877.  *  The default destructor for a SOM object. A nonzero <doFree>
  878.  *  indicates that the object storage should be freed by the
  879.  *  object's class (via somDeallocate) after uninitialization.
  880.  *  As with somDefaultInit, a null ctrl can be passed.
  881.  */
  882.    SOM_ResolveD(this,somf_TDeque,SOMObject,somDestruct)
  883.     (this,doFree,ctrl);
  884. }
  885.  
  886.  
  887. /* initializer method: somDefaultCopyInit */
  888. void   somDefaultCopyInit(som3InitCtrl* ctrl, 
  889.         SOMObject* fromObj)
  890. {
  891. /*
  892.  *  A default copy constructor. Use this to make copies of objects for
  893.  *  calling methods with "by-value" argument semantics.
  894.  */
  895.    SOM_ResolveD(this,somf_TDeque,SOMObject,somDefaultCopyInit)
  896.     (this,ctrl,fromObj);
  897. }
  898.  
  899.  
  900. /* method: somDefaultAssign */
  901. somf_TDeque*  somDefaultAssign(som3AssignCtrl* ctrl, 
  902.         SOMObject* fromObj)
  903. {
  904. /*
  905.  *  A default assignment operator. Use this to "assign" the state of one
  906.  *  object to another.
  907.  */
  908.    return SOM_ResolveD(this,somf_TDeque,SOMObject,somDefaultAssign)
  909.     (this,ctrl,fromObj);
  910. }
  911.  
  912.  
  913. /* initializer method: somDefaultConstCopyInit */
  914. void   somDefaultConstCopyInit(som3InitCtrl* ctrl, 
  915.         SOMObject* fromObj)
  916. {
  917. /*
  918.  *  A default copy constructor that uses a const fromObj.
  919.  */
  920.    SOM_ResolveD(this,somf_TDeque,SOMObject,somDefaultConstCopyInit)
  921.     (this,ctrl,fromObj);
  922. }
  923.  
  924.  
  925. /* initializer method: somDefaultVCopyInit */
  926. void   somDefaultVCopyInit(som3InitCtrl* ctrl, 
  927.         SOMObject* fromObj)
  928. {
  929. /*
  930.  *  A default copy constructor that uses a volatile fromObj.
  931.  */
  932.    SOM_ResolveD(this,somf_TDeque,SOMObject,somDefaultVCopyInit)
  933.     (this,ctrl,fromObj);
  934. }
  935.  
  936.  
  937. /* initializer method: somDefaultConstVCopyInit */
  938. void   somDefaultConstVCopyInit(som3InitCtrl* ctrl, 
  939.         SOMObject* fromObj)
  940. {
  941. /*
  942.  *  A default copy constructor that uses a const volatile fromObj.
  943.  */
  944.    SOM_ResolveD(this,somf_TDeque,SOMObject,somDefaultConstVCopyInit)
  945.     (this,ctrl,fromObj);
  946. }
  947.  
  948.  
  949. /* method: somDefaultConstAssign */
  950. somf_TDeque*  somDefaultConstAssign(som3AssignCtrl* ctrl, 
  951.         SOMObject* fromObj)
  952. {
  953. /*
  954.  *  A default assignment operator that uses a const fromObj.
  955.  */
  956.    return SOM_ResolveD(this,somf_TDeque,SOMObject,somDefaultConstAssign)
  957.     (this,ctrl,fromObj);
  958. }
  959.  
  960.  
  961. /* method: somDefaultVAssign */
  962. somf_TDeque*  somDefaultVAssign(som3AssignCtrl* ctrl, 
  963.         SOMObject* fromObj)
  964. {
  965. /*
  966.  *  A default assignment operator that uses a volatile fromObj.
  967.  */
  968.    return SOM_ResolveD(this,somf_TDeque,SOMObject,somDefaultVAssign)
  969.     (this,ctrl,fromObj);
  970. }
  971.  
  972.  
  973. /* method: somDefaultConstVAssign */
  974. somf_TDeque*  somDefaultConstVAssign(som3AssignCtrl* ctrl, 
  975.         SOMObject* fromObj)
  976. {
  977. /*
  978.  *  A default assignment operator that uses a const volatile fromObj.
  979.  */
  980.    return SOM_ResolveD(this,somf_TDeque,SOMObject,somDefaultConstVAssign)
  981.     (this,ctrl,fromObj);
  982. }
  983.  
  984.  
  985. /* method: somFree */
  986. void   somFree()
  987. {
  988. /*
  989.  *  Use as directed by framework implementations.
  990.  */
  991.    SOM_ResolveD(this,somf_TDeque,SOMObject,somFree)
  992.     (this);
  993. }
  994.  
  995.  
  996. /* method: somUninit */
  997. void   somUninit()
  998. {
  999. /*
  1000.  *  Obsolete but still supported. Override somDestruct instead of somUninit.
  1001.  */
  1002.    SOM_ResolveD(this,somf_TDeque,SOMObject,somUninit)
  1003.     (this);
  1004. }
  1005.  
  1006.  
  1007. /* method: somGetClass */
  1008. SOMClass*   somGetClass()
  1009. {
  1010. /*
  1011.  *  Return the receiver's class.
  1012.  */
  1013.    return SOM_ResolveD(this,somf_TDeque,SOMObject,somGetClass)
  1014.     (this);
  1015. }
  1016.  
  1017.  
  1018. /* method: somGetClassName */
  1019. string   somGetClassName()
  1020. {
  1021. /*
  1022.  *  Return the name of the receiver's class.
  1023.  */
  1024.    return SOM_ResolveD(this,somf_TDeque,SOMObject,somGetClassName)
  1025.     (this);
  1026. }
  1027.  
  1028.  
  1029. /* method: somGetSize */
  1030. long   somGetSize()
  1031. {
  1032. /*
  1033.  *  Return the size of the receiver.
  1034.  */
  1035.    return SOM_ResolveD(this,somf_TDeque,SOMObject,somGetSize)
  1036.     (this);
  1037. }
  1038.  
  1039.  
  1040. /* method: somIsA */
  1041. boolean   somIsA(SOMClass* aClassObj)
  1042. {
  1043. /*
  1044.  *  Returns 1 (true) if the receiver responds to methods
  1045.  *  introduced by <aClassObj>, and 0 (false) otherwise.
  1046.  */
  1047.    return SOM_ResolveD(this,somf_TDeque,SOMObject,somIsA)
  1048.     (this,aClassObj);
  1049. }
  1050.  
  1051.  
  1052. /* method: somIsInstanceOf */
  1053. boolean   somIsInstanceOf(SOMClass* aClassObj)
  1054. {
  1055. /*
  1056.  *  Returns 1 (true) if the receiver is an instance of
  1057.  *  <aClassObj> and 0 (false) otherwise.
  1058.  */
  1059.    return SOM_ResolveD(this,somf_TDeque,SOMObject,somIsInstanceOf)
  1060.     (this,aClassObj);
  1061. }
  1062.  
  1063.  
  1064. /* method: somRespondsTo */
  1065. boolean   somRespondsTo(somId mId)
  1066. {
  1067. /*
  1068.  *  Returns 1 (true) if the indicated method can be invoked
  1069.  *  on the receiver and 0 (false) otherwise.
  1070.  */
  1071.    return SOM_ResolveD(this,somf_TDeque,SOMObject,somRespondsTo)
  1072.     (this,mId);
  1073. }
  1074.  
  1075.  
  1076. /* va_list method: somDispatch */
  1077.  
  1078. /*
  1079.  *  This method provides a generic, class-specific dispatch mechanism.
  1080.  *  It accepts as input <retValue> a pointer to the memory area to be
  1081.  *  loaded with the result of dispatching the method indicated by
  1082.  *  <methodId> using the arguments in <ap>. <ap> contains the object
  1083.  *  on which the method is to be invoked as the first argument.
  1084.  */
  1085. /* the va_list invocation form */
  1086. boolean   somf_TDeque_somDispatch(somToken* retValue, 
  1087.         somId methodId, 
  1088.         va_list ap)
  1089. {return SOM_ResolveD(this,somf_TDeque,SOMObject,somDispatch)
  1090.     (this,retValue,methodId,ap);
  1091. }
  1092.  
  1093. /* the varargs invocation form */
  1094. boolean   somDispatch(somToken* retValue, 
  1095.         somId methodId, 
  1096.         ...)
  1097. {
  1098. /*
  1099.  *  This method provides a generic, class-specific dispatch mechanism.
  1100.  *  It accepts as input <retValue> a pointer to the memory area to be
  1101.  *  loaded with the result of dispatching the method indicated by
  1102.  *  <methodId> using the arguments in <ap>. <ap> contains the object
  1103.  *  on which the method is to be invoked as the first argument.
  1104.  */
  1105.    va_list ap;
  1106.    va_start(ap, methodId);
  1107.    boolean __somResult = 
  1108.       SOM_ResolveD(this,somf_TDeque,SOMObject,somDispatch)
  1109.     (this,retValue,methodId,ap);
  1110.    va_end(ap);
  1111.    return __somResult;
  1112. }
  1113.  
  1114.  
  1115. /* va_list method: somClassDispatch */
  1116.  
  1117. /*
  1118.  *  Like somDispatch, but method resolution for static methods is done
  1119.  *  according to the clsObj instance method table.
  1120.  */
  1121. /* the va_list invocation form */
  1122. boolean   somf_TDeque_somClassDispatch(SOMClass* clsObj, 
  1123.         somToken* retValue, 
  1124.         somId methodId, 
  1125.         va_list ap)
  1126. {return SOM_ResolveD(this,somf_TDeque,SOMObject,somClassDispatch)
  1127.     (this,clsObj,retValue,methodId,ap);
  1128. }
  1129.  
  1130. /* the varargs invocation form */
  1131. boolean   somClassDispatch(SOMClass* clsObj, 
  1132.         somToken* retValue, 
  1133.         somId methodId, 
  1134.         ...)
  1135. {
  1136. /*
  1137.  *  Like somDispatch, but method resolution for static methods is done
  1138.  *  according to the clsObj instance method table.
  1139.  */
  1140.    va_list ap;
  1141.    va_start(ap, methodId);
  1142.    boolean __somResult = 
  1143.       SOM_ResolveD(this,somf_TDeque,SOMObject,somClassDispatch)
  1144.     (this,clsObj,retValue,methodId,ap);
  1145.    va_end(ap);
  1146.    return __somResult;
  1147. }
  1148.  
  1149.  
  1150. /* method: somCastObj */
  1151. boolean   somCastObj(SOMClass* cls)
  1152. {
  1153. /*
  1154.  *  cast the receiving object to cls (which must be an ancestor of the
  1155.  *  objects true class. Returns true on success.
  1156.  */
  1157.    return SOM_ResolveD(this,somf_TDeque,SOMObject,somCastObj)
  1158.     (this,cls);
  1159. }
  1160.  
  1161.  
  1162. /* method: somResetObj */
  1163. boolean   somResetObj()
  1164. {
  1165. /*
  1166.  *  reset an object to its true class. Returns true always.
  1167.  */
  1168.    return SOM_ResolveD(this,somf_TDeque,SOMObject,somResetObj)
  1169.     (this);
  1170. }
  1171.  
  1172.  
  1173. /* va_list method: somDispatchV */
  1174.  
  1175. /*
  1176.  *  Obsolete. Use somDispatch instead.
  1177.  */
  1178. /* the va_list invocation form */
  1179. void   somf_TDeque_somDispatchV(somId methodId, 
  1180.         somId descriptor, 
  1181.         va_list ap)
  1182. {   SOM_ResolveD(this,somf_TDeque,SOMObject,somDispatchV)
  1183.     (this,methodId,descriptor,ap);
  1184. }
  1185.  
  1186. /* the varargs invocation form */
  1187. void   somDispatchV(somId methodId, 
  1188.         somId descriptor, 
  1189.         ...)
  1190. {
  1191. /*
  1192.  *  Obsolete. Use somDispatch instead.
  1193.  */
  1194.    va_list ap;
  1195.    va_start(ap, descriptor);
  1196.    SOM_ResolveD(this,somf_TDeque,SOMObject,somDispatchV)
  1197.     (this,methodId,descriptor,ap);
  1198.    va_end(ap);
  1199. }
  1200.  
  1201.  
  1202. /* va_list method: somDispatchL */
  1203.  
  1204. /*
  1205.  *  Obsolete. Use somDispatch instead.
  1206.  */
  1207. /* the va_list invocation form */
  1208. long   somf_TDeque_somDispatchL(somId methodId, 
  1209.         somId descriptor, 
  1210.         va_list ap)
  1211. {return SOM_ResolveD(this,somf_TDeque,SOMObject,somDispatchL)
  1212.     (this,methodId,descriptor,ap);
  1213. }
  1214.  
  1215. /* the varargs invocation form */
  1216. long   somDispatchL(somId methodId, 
  1217.         somId descriptor, 
  1218.         ...)
  1219. {
  1220. /*
  1221.  *  Obsolete. Use somDispatch instead.
  1222.  */
  1223.    va_list ap;
  1224.    va_start(ap, descriptor);
  1225.    long __somResult = 
  1226.       SOM_ResolveD(this,somf_TDeque,SOMObject,somDispatchL)
  1227.     (this,methodId,descriptor,ap);
  1228.    va_end(ap);
  1229.    return __somResult;
  1230. }
  1231.  
  1232.  
  1233. /* va_list method: somDispatchA */
  1234.  
  1235. /*
  1236.  *  Obsolete. Use somDispatch instead.
  1237.  */
  1238. /* the va_list invocation form */
  1239. void*   somf_TDeque_somDispatchA(somId methodId, 
  1240.         somId descriptor, 
  1241.         va_list ap)
  1242. {return SOM_ResolveD(this,somf_TDeque,SOMObject,somDispatchA)
  1243.     (this,methodId,descriptor,ap);
  1244. }
  1245.  
  1246. /* the varargs invocation form */
  1247. void*   somDispatchA(somId methodId, 
  1248.         somId descriptor, 
  1249.         ...)
  1250. {
  1251. /*
  1252.  *  Obsolete. Use somDispatch instead.
  1253.  */
  1254.    va_list ap;
  1255.    va_start(ap, descriptor);
  1256.    void* __somResult = 
  1257.       SOM_ResolveD(this,somf_TDeque,SOMObject,somDispatchA)
  1258.     (this,methodId,descriptor,ap);
  1259.    va_end(ap);
  1260.    return __somResult;
  1261. }
  1262.  
  1263.  
  1264. /* va_list method: somDispatchD */
  1265.  
  1266. /*
  1267.  *  Obsolete. Use somDispatch instead.
  1268.  */
  1269. /* the va_list invocation form */
  1270. double   somf_TDeque_somDispatchD(somId methodId, 
  1271.         somId descriptor, 
  1272.         va_list ap)
  1273. {return SOM_ResolveD(this,somf_TDeque,SOMObject,somDispatchD)
  1274.     (this,methodId,descriptor,ap);
  1275. }
  1276.  
  1277. /* the varargs invocation form */
  1278. double   somDispatchD(somId methodId, 
  1279.         somId descriptor, 
  1280.         ...)
  1281. {
  1282. /*
  1283.  *  Obsolete. Use somDispatch instead.
  1284.  */
  1285.    va_list ap;
  1286.    va_start(ap, descriptor);
  1287.    double __somResult = 
  1288.       SOM_ResolveD(this,somf_TDeque,SOMObject,somDispatchD)
  1289.     (this,methodId,descriptor,ap);
  1290.    va_end(ap);
  1291.    return __somResult;
  1292. }
  1293.  
  1294.  
  1295. /* method: somPrintSelf */
  1296. SOMObject*   somPrintSelf()
  1297. {
  1298. /*
  1299.  *  Uses <SOMOutCharRoutine> to write a brief string with identifying
  1300.  *  information about this object.  The default implementation just gives
  1301.  *  the object's class name and its address in memory.
  1302.  *  <self> is returned.
  1303.  */
  1304.    return SOM_ResolveD(this,somf_TDeque,SOMObject,somPrintSelf)
  1305.     (this);
  1306. }
  1307.  
  1308.  
  1309. /* method: somDumpSelf */
  1310. void   somDumpSelf(long level)
  1311. {
  1312. /*
  1313.  *  Uses <SOMOutCharRoutine> to write a detailed description of this object
  1314.  *  and its current state.
  1315.  * 
  1316.  *  <level> indicates the nesting level for describing compound objects
  1317.  *  it must be greater than or equal to zero.  All lines in the
  1318.  *  description will be preceeded by <2*level> spaces.
  1319.  * 
  1320.  *  This routine only actually writes the data that concerns the object
  1321.  *  as a whole, such as class, and uses <somDumpSelfInt> to describe
  1322.  *  the object's current state.  This approach allows readable
  1323.  *  descriptions of compound objects to be constructed.
  1324.  * 
  1325.  *  Generally it is not necessary to override this method, if it is
  1326.  *  overriden it generally must be completely replaced.
  1327.  */
  1328.    SOM_ResolveD(this,somf_TDeque,SOMObject,somDumpSelf)
  1329.     (this,level);
  1330. }
  1331.  
  1332.  
  1333. /* method: somDumpSelfInt */
  1334. void   somDumpSelfInt(long level)
  1335. {
  1336. /*
  1337.  *  Uses <SOMOutCharRoutine> to write in the current state of this object.
  1338.  *  Generally this method will need to be overridden.  When overriding
  1339.  *  it, begin by calling the parent class form of this method and then
  1340.  *  write in a description of your class's instance data. This will
  1341.  *  result in a description of all the object's instance data going
  1342.  *  from its root ancestor class to its specific class.
  1343.  */
  1344.    SOM_ResolveD(this,somf_TDeque,SOMObject,somDumpSelfInt)
  1345.     (this,level);
  1346. }
  1347.  
  1348.  
  1349.  
  1350. };   /* somf_TDeque */
  1351.  
  1352.  
  1353.  
  1354. #endif       /* SOM_somf_TDeque_xh */
  1355.