home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / cset21v1.zip / IBMCPP / IBMCLASS / ISTDOPS.H < prev    next >
Text File  |  1993-09-22  |  7KB  |  273 lines
  1. /*******************************************************************************
  2. *                                                                              *
  3. * COPYRIGHT:                                                                   *
  4. *   IBM C/C++ Tools Version 2.01 - Collection Class Library                    *
  5. *   Licensed Materials - Property of IBM                                       *
  6. *   (C) Copyright IBM Corporation 1992, 1993                                   *
  7. *   All Rights Reserved                                                        *
  8. *   US Government Users Restricted Rights - Use, duplication, or disclosure    *
  9. *   restricted by GSA ADP Schedule Contract with IBM Corp.                     *
  10. *                                                                              *
  11. *******************************************************************************/
  12. #ifndef _ISTDOPS_H
  13. #define _ISTDOPS_H
  14.  
  15. #include <iglobals.h>
  16. #include <string.h>
  17.  
  18. // indirection for function/operator application
  19.  
  20. template < class Element >
  21. inline Element& elementForOps (Element& e)
  22. { return e; }
  23.  
  24. template < class Element >
  25. inline Element const& elementForOps (Element const& e)
  26. { return e; }
  27.  
  28. // memory management
  29.  
  30. #if defined (__IBMCPP__) && defined (__DEBUG_ALLOC__)
  31.  
  32. class IStdMemOps {
  33. public:
  34.   void*          allocate   (size_t s, char const* fn, size_t ln) const;
  35.   void           deallocate (void* p, char const* fn, size_t ln) const;
  36. };
  37.  
  38. inline void* IStdMemOps::
  39. allocate (size_t s, char const* fn, size_t ln) const
  40. { return ::operator new (s, fn, ln);
  41. }
  42.  
  43. inline void IStdMemOps::
  44. deallocate (void* p, char const* fn, size_t ln) const
  45. { ::operator delete (p, fn, ln);
  46. }
  47.  
  48. #else
  49.  
  50. class IStdMemOps {
  51. public:
  52.   void*          allocate   (size_t s) const;
  53.   void           deallocate (void* p) const;
  54. };
  55.  
  56. inline void* IStdMemOps::
  57. allocate (size_t s) const
  58. { return ::operator new (s);
  59. }
  60.  
  61. inline void IStdMemOps::
  62. deallocate (void* p) const
  63. { ::operator delete (p);
  64. }
  65.  
  66. #endif // __IBMCPP__ && __DEBUG_ALLOC__
  67.  
  68. // assignment
  69.  
  70. template < class Element >
  71. inline void assign (Element& e1, Element const& e2) {
  72.   e1 = e2;
  73. }
  74.  
  75. template < class Element >
  76. class IStdAsOps {
  77. public:
  78.   void           assign (Element& e1, Element const& e2) const;
  79. };
  80.  
  81. template < class Element >
  82. inline void IStdAsOps < Element >::
  83. assign (Element& e1, Element const& e2) const {
  84.   ::assign (e1, e2);
  85. }
  86.  
  87. // equality
  88.  
  89. template < class Element >
  90. inline IBoolean equal (Element const& e1, Element const& e2) {
  91.   return e1 == e2;
  92. }
  93.  
  94. inline IBoolean equal (char const* e1, char const* e2) {
  95.   return strcmp (e1, e2) == 0;
  96. }
  97.  
  98. template < class Element >
  99. class IStdEqOps {
  100. public:
  101.   IBoolean        equal (Element const& e1, Element const& e2) const;
  102. };
  103.  
  104. template < class Element >
  105. inline IBoolean IStdEqOps < Element >::
  106. equal (Element const& e1, Element const& e2) const {
  107.   return ::equal (elementForOps (e1), elementForOps (e2));
  108. }
  109.  
  110. // ordering relation
  111.  
  112. template < class Element >
  113. inline long compare (Element const& e1, Element const& e2) {
  114.   if      (e1 < e2) return -1;
  115.   else if (e2 < e1) return 1;
  116.   else              return 0;
  117. }
  118.  
  119. inline long compare (int e1, int e2) {
  120.   return e1 - e2;
  121. }
  122.  
  123. inline long compare (char const* e1, char const* e2) {
  124.   return strcmp (e1, e2);
  125. }
  126.  
  127. template < class Element >
  128. class IStdCmpOps {
  129. public:
  130.   long           compare (Element const& e1, Element const& e2) const;
  131. };
  132.  
  133. template < class Element >
  134. inline long IStdCmpOps < Element >::
  135. compare (Element const& e1, Element const& e2) const {
  136.   return ::compare (elementForOps (e1), elementForOps (e2));
  137. }
  138.  
  139. // hash function
  140.  
  141. inline unsigned long hash (int e, unsigned long n) {
  142.   return e % n;
  143. }
  144.  
  145. inline unsigned long hash (char const* e, unsigned long n) {
  146.   unsigned int len = strlen (e);
  147.   if (len == 0)
  148.     return 0;
  149.   else
  150.     return (e [0] + e [len-1] + e [len/2]) % n;
  151. }
  152.  
  153. template < class Element >
  154. class IStdHshOps {
  155. public:
  156.   unsigned long  hash (Element const& e, unsigned long n) const;
  157. };
  158.  
  159. template < class Element >
  160. inline unsigned long IStdHshOps < Element >::
  161. hash (Element const& e, unsigned long n) const {
  162.   return ::hash (elementForOps (e), n);
  163. }
  164.  
  165. // key selection
  166.  
  167. template < class Element, class Key >
  168. class IStdKeyOps {
  169. public:
  170.   Key const& key (Element const& e) const;
  171. };
  172.  
  173. template < class Element, class Key >
  174. inline Key const& IStdKeyOps < Element, Key >::
  175. key (Element const& e) const {
  176.   return ::key (elementForOps (e));
  177. }
  178.  
  179. // standard operation combinations
  180.  
  181. template < class Element >
  182. class IStdOps : public IStdMemOps,
  183.                 public IStdAsOps < Element > {
  184. };
  185.  
  186. template < class Element >
  187. class IEOps : public IStdOps < Element >,
  188.               public IStdEqOps < Element > {
  189. };
  190.  
  191. template < class Element >
  192. class IECOps : public IEOps < Element >,
  193.                public IStdCmpOps < Element > {
  194. };
  195.  
  196. template < class Element >
  197. class IEHOps : public IEOps < Element >,
  198.                public IStdHshOps < Element > {
  199. };
  200.  
  201. template < class Element, class Key >
  202. class IKCOps : public IStdOps < Element >,
  203.                public IStdKeyOps < Element, Key > {
  204. public:
  205.   class KeyOps : public IStdCmpOps < Key > {
  206.   } keyOps;
  207. };
  208.  
  209. template < class Element, class Key >
  210. class IKEHOps : public IStdOps < Element >,
  211.                 public IStdKeyOps < Element, Key > {
  212. public:
  213.   class KeyOps : public IStdEqOps < Key >,
  214.                  public IStdHshOps < Key > {
  215.   } keyOps;
  216. };
  217.  
  218. template < class Element, class Key >
  219. class IEKCOps : public IEOps < Element >,
  220.                 public IStdKeyOps < Element, Key > {
  221. public:
  222.   class KeyOps : public IStdCmpOps < Key > {
  223.   } keyOps;
  224. };
  225.  
  226. template < class Element, class Key >
  227. class IEKEHOps : public IEOps < Element >,
  228.                  public IStdKeyOps < Element, Key > {
  229. public:
  230.   class KeyOps : public IStdEqOps < Key >,
  231.                  public IStdHshOps < Key > {
  232.   } keyOps;
  233. };
  234.  
  235. // definition macor for templates with given operation class
  236.  
  237. #define IDefineCollectionWithOps(IGCollection, Ops, ICollection) \
  238. template < class Element > \
  239. class ICollection : \
  240.   public IGCollection < Element, Ops < Element > > { \
  241. public: \
  242.   ICollection (INumber n = 100) : \
  243.     IGCollection < Element, Ops < Element > > (n) {} \
  244. };
  245.  
  246. #define IDefineKeyCollectionWithOps(IGCollection, Ops, ICollection) \
  247. template < class Element, class Key > \
  248. class ICollection : \
  249.   public IGCollection < Element, Key, Ops < Element, Key > > { \
  250. public: \
  251.   ICollection (INumber n = 100) : \
  252.     IGCollection < Element, Key, Ops < Element, Key > > (n) {} \
  253. };
  254.  
  255. #define IDefineStdCollectionWithOps(Collection) IDefineCollectionWithOps \
  256.   (IG ## Collection, I ## Collection ## Ops, I ## Collection)
  257.  
  258. #define IDefineStdKeyCollectionWithOps(Collection) IDefineKeyCollectionWithOps \
  259.   (IG ## Collection, I ## Collection ## Ops, I ## Collection)
  260.  
  261. // key extension
  262.  
  263. template < class Element, class ElementOps >
  264. class IOpsWithKey : public ElementOps {
  265. public:
  266.   Element const& key (Element const& e) const {
  267.     return e;
  268.   }
  269.   ElementOps keyOps;
  270. };
  271.  
  272. #endif
  273.