home *** CD-ROM | disk | FTP | other *** search
/ Power GUI Programming with VisualAge C++ / powergui.iso / trialva / ibmcppw / include / istdops.h < prev    next >
Encoding:
C/C++ Source or Header  |  1996-02-22  |  8.5 KB  |  355 lines

  1. /**********************************************************************
  2. *                                                                     *
  3. *  IBM(R) VisualAge(TM) for C++ for Windows(R), Version 3.5           *
  4. *                                                                     *
  5. *  PID: 5622-880                                                      *
  6. *  - Licensed Material - Program-Property of IBM                      *
  7. *  (C) Copyright IBM Corp. 1991, 1995 - All Right Reserved.           *
  8. *                                                                     *
  9. *  US Government Users Restricted Rights - Use, duplication or        *
  10. *  disclosure restricted by GSA ADP Schedule Contract with IBM Corp.  *
  11. *                                                                     *
  12. *  VisualAge, and IBM are trademarks or registered trademarks of      *
  13. *  International Business Machines Corporation.                       *
  14. *  Windows is a registered trademark of Microsoft Corporation.        *
  15. *                                                                     *
  16. **********************************************************************/
  17.  
  18. #ifndef _ISTDOPS_H
  19. #define _ISTDOPS_H
  20.  
  21. #include <iglobals.h>
  22. #include <stddef.h>
  23.  
  24.  
  25. #pragma info (nocls, nocnd, nocns, nocnv, noext, nognr, novft)
  26. #pragma pack (4)
  27.  
  28. #pragma SOMAsDefault(off)
  29.  
  30. // indirection for function/operator application
  31.  
  32. template <class Element>
  33. Element& elementForOps (Element& e);
  34.  
  35. template <class Element>
  36. Element const& elementForOps (Element const& e);
  37.  
  38. // memory management
  39.  
  40. class IStdMemOps {
  41. public:
  42.  
  43.   void* allocate   (size_t
  44. #if defined (__DEBUG_ALLOC__)
  45.                     , char const*, unsigned long
  46. #endif
  47.                    ) const;
  48.  
  49.   void  deallocate (void*
  50. #if defined (__DEBUG_ALLOC__)
  51.                     , char const*, unsigned long
  52. #endif
  53.                    ) const;
  54.  
  55. };
  56.  
  57. template <class ElementOps>
  58. class IWStdMemOps {
  59.   ElementOps ivElementOps;
  60. public:
  61.  
  62.   void* Allocate   (size_t
  63. #if defined (__DEBUG_ALLOC__)
  64.                     , char const*, unsigned long
  65. #endif
  66.                    ) const;
  67.  
  68.   void  Deallocate (void*
  69. #if defined (__DEBUG_ALLOC__)
  70.                     , char const*, unsigned long
  71. #endif
  72.                    ) const;
  73.  
  74. };
  75.  
  76. // assignment
  77.  
  78. template <class Element>
  79. class IStdAsOps {
  80. public:
  81.   void assign (Element&, Element const&) const;
  82. };
  83.  
  84. template <class Element, class ElementOps>
  85. class IWStdAsOps {
  86.   ElementOps ivElementOps;
  87. public:
  88.   void Assign (Element&, Element const&) const;
  89. };
  90.  
  91. // equality
  92.  
  93. template <class Element>
  94. class IStdEqOps {
  95. public:
  96.   IBoolean equal (Element const&, Element const&) const;
  97. };
  98.  
  99. template <class Element, class ElementOps>
  100. class IWStdEqOps {
  101.   ElementOps ivElementOps;
  102. public:
  103.   IBoolean Equal (Element const&, Element const&) const;
  104. };
  105.  
  106. template <class Key, class ElementOps>
  107. class IWStdEqKeyOps {
  108.   ElementOps ivElementOps;
  109. public:
  110.   IBoolean Equal (Key const&, Key const&) const;
  111. };
  112.  
  113. // ordering relation
  114.  
  115. template <class Element>
  116. class IStdCmpOps {
  117. public:
  118.   long compare (Element const&, Element const&) const;
  119. };
  120.  
  121. template <class Element, class ElementOps>
  122. class IWStdCmpOps {
  123.   ElementOps ivElementOps;
  124. public:
  125.   long Compare (Element const&, Element const&) const;
  126. };
  127.  
  128. template <class Key, class ElementOps>
  129. class IWStdCmpKeyOps {
  130.   ElementOps ivElementOps;
  131. public:
  132.   long Compare (Key const&, Key const&) const;
  133. };
  134.  
  135. // hash function
  136.  
  137. template <class Element>
  138. class IStdHshOps {
  139. public:
  140.   unsigned long hash (Element const&, unsigned long) const;
  141. };
  142.  
  143. template <class Element, class ElementOps>
  144. class IWStdHshOps {
  145.   ElementOps ivElementOps;
  146. public:
  147.   unsigned long Hash (Element const&, unsigned long) const;
  148. };
  149.  
  150. template <class Key, class ElementOps>
  151. class IWStdHshKeyOps {
  152.   ElementOps ivElementOps;
  153. public:
  154.   unsigned long Hash (Key const&, unsigned long) const;
  155. };
  156.  
  157. // key selection
  158.  
  159. template <class Element, class Key>
  160. class IStdKeyOps {
  161. public:
  162.   Key const& key (Element const&) const;
  163. };
  164.  
  165. template <class Element, class _Key, class ElementOps>
  166. class IWStdKeyOps {
  167.   ElementOps ivElementOps;
  168. public:
  169.   _Key const& Key (Element const&) const;
  170. };
  171.  
  172. // standard operation combinations
  173.  
  174. template <class Element>
  175. class IStdOps : public IStdMemOps,
  176.                 public IStdAsOps <Element> {
  177. };
  178.  
  179. class TStream;
  180.  
  181. template <class Element, class ElementOps>
  182. class IWStdOps :
  183.   public IWStdMemOps <ElementOps>,
  184.   public IWStdAsOps <Element, ElementOps> {
  185. public:
  186.   IWStdOps (void* = 0) {}
  187.  
  188.   // for Taligent compliance
  189.   TStream& operator<<= (TStream&);
  190.   TStream& operator>>= (TStream&) const;
  191.   void StreamIn  (Element&, TStream&) const;
  192.   void StreamOut (Element const&, TStream&) const;
  193.   static Element* GetStreamable ();
  194. };
  195.  
  196. template <class Element>
  197. class IEOps : public IStdOps <Element>,
  198.               public IStdEqOps <Element> {
  199. };
  200.  
  201. template <class Element, class ElementOps>
  202. class IWEOps :
  203.   public IWStdOps <Element, ElementOps>,
  204.   public IWStdEqOps <Element, ElementOps> {
  205. public:
  206.   IWEOps (void* = 0) {}
  207. };
  208.  
  209. template <class Element>
  210. class ICOps : public IStdOps <Element>,
  211.               public IStdCmpOps <Element> {
  212. };
  213.  
  214. template <class Element, class ElementOps>
  215. class IWCOps :
  216.   public IWStdOps <Element, ElementOps>,
  217.   public IWStdCmpOps <Element, ElementOps> {
  218. public:
  219.   IWCOps (void* = 0) {}
  220. };
  221.  
  222. // for backward compatibility
  223. template <class Element>
  224. class IECOps : public IEOps <Element>,
  225.                public IStdCmpOps <Element> {
  226. };
  227.  
  228. template <class Element>
  229. class IEHOps : public IEOps <Element>,
  230.                public IStdHshOps <Element> {
  231. };
  232.  
  233. template <class Element, class ElementOps>
  234. class IWEHOps :
  235.   public IWEOps <Element, ElementOps>,
  236.   public IWStdHshOps <Element, ElementOps> {
  237. public:
  238.   IWEHOps (void* = 0) {}
  239. };
  240.  
  241. template <class Key>
  242. class IKCKeyOps : public IStdCmpOps <Key> {
  243. };
  244.  
  245. template <class Key, class ElementOps>
  246. class IWKCKeyOps :
  247.   public IWStdCmpKeyOps <Key, ElementOps> {
  248. };
  249.  
  250. template <class Element, class Key>
  251. class IKCOps : public IStdOps <Element>,
  252.                public IStdKeyOps <Element, Key> {
  253. public:
  254.   IKCKeyOps <Key> keyOps;
  255. };
  256.  
  257. template <class Element, class _Key, class ElementOps>
  258. class IWKCOps :
  259.   public IWStdOps <Element, ElementOps>,
  260.   public IWStdKeyOps <Element, _Key, ElementOps> {
  261. public:
  262.   IWKCKeyOps <_Key, ElementOps> keyOps;
  263.   IWKCOps (void* = 0) {};
  264. };
  265.  
  266. template <class Key>
  267. class IKEHKeyOps : public IStdEqOps <Key>,
  268.                    public IStdHshOps <Key> {
  269. };
  270.  
  271. template <class Key, class ElementOps>
  272. class IWKEHKeyOps :
  273.   public IWStdEqKeyOps <Key, ElementOps>,
  274.   public IWStdHshKeyOps <Key, ElementOps> {
  275. public:
  276. };
  277.  
  278. template <class Element, class Key>
  279. class IKEHOps : public IStdOps <Element>,
  280.                 public IStdKeyOps <Element, Key> {
  281. public:
  282.   IKEHKeyOps <Key> keyOps;
  283. };
  284.  
  285. template <class Element, class _Key, class ElementOps>
  286. class IWKEHOps :
  287.   public IWStdOps <Element, ElementOps>,
  288.   public IWStdKeyOps <Element, _Key, ElementOps> {
  289. public:
  290.   IWKEHKeyOps <_Key, ElementOps> keyOps;
  291.   IWKEHOps (void* = 0) {}
  292. };
  293.  
  294. template <class Key>
  295. class IEKCKeyOps : public IStdCmpOps <Key> {
  296. };
  297.  
  298. template <class Key, class ElementOps>
  299. class IWEKCKeyOps :
  300.   public IWStdCmpKeyOps <Key, ElementOps> {
  301. };
  302.  
  303. template <class Element, class Key>
  304. class IEKCOps : public IEOps <Element>,
  305.                 public IStdKeyOps <Element, Key> {
  306. public:
  307.   IEKCKeyOps <Key> keyOps;
  308. };
  309.  
  310. template <class Element, class _Key, class ElementOps>
  311. class IWEKCOps :
  312.   public IWEOps <Element, ElementOps>,
  313.   public IWStdKeyOps <Element, _Key, ElementOps> {
  314. public:
  315.   IWEKCKeyOps <_Key, ElementOps> keyOps;
  316.   IWEKCOps (void* = 0) {}
  317. };
  318.  
  319. template <class Key>
  320. class IEKEHKeyOps : public IStdEqOps <Key>,
  321.                     public IStdHshOps <Key> {
  322. };
  323.  
  324. template <class Key, class ElementOps>
  325. class IWEKEHKeyOps :
  326.   public IWStdEqKeyOps <Key, ElementOps>,
  327.   public IWStdHshKeyOps <Key, ElementOps> {
  328. };
  329.  
  330. template <class Element, class Key>
  331. class IEKEHOps : public IEOps <Element>,
  332.                  public IStdKeyOps <Element, Key> {
  333. public:
  334.   IEKEHKeyOps <Key> keyOps;
  335. };
  336.  
  337.  
  338. template <class Element, class _Key, class ElementOps>
  339. class IWEKEHOps :
  340.   public IWEOps <Element, ElementOps>,
  341.   public IWStdKeyOps <Element, _Key, ElementOps> {
  342. public:
  343.   IWEKEHKeyOps <_Key, ElementOps> keyOps;
  344.   IWEKEHOps (void* = 0) {}
  345. };
  346.  
  347. #include <istdops.inl>
  348.  
  349. #pragma SOMAsDefault(pop)
  350.  
  351. #pragma info (restore)
  352. #pragma pack ()
  353.  
  354. #endif
  355.