Category

Development Platform
Home > SourceCode/Document > Mathimatics-Numerical algorithms > View Code
handle_types.h
Package: leda.tar.gz　[view]
Upload User: gzelex
Upload Date: 2007-01-07
Package Size: 707k
Code Size: 3k
Category:

Mathimatics-Numerical algorithms

Development Platform:

MultiPlatform

handle_types.h：Code Content
  1. /*******************************************************************************
  2. +
  3. +  LEDA-R  3.2.3
  4. +
  5. +  handle_types.h
  6. +
  7. +  Copyright (c) 1995  by  Max-Planck-Institut fuer Informatik
  8. +  Im Stadtwald, 66123 Saarbruecken, Germany     
  9. +  All rights reserved.
  10. + 
  11. *******************************************************************************/
  13. #ifndef LEDA_HANDLE_H
  14. #define LEDA_HANDLE_H
  16. //------------------------------------------------------------------------------
  17. // handle_base/rep: base classes for handle types string, point, segment,...
  18. //------------------------------------------------------------------------------
  21. class handle_rep  {
  23. friend class handle_base;
  25. protected:
  27.  int  count;
  29.  handle_rep()  { count = 1; }
  30.  virtual ~handle_rep()  {}
  32. public:
  34.  LEDA_MEMORY(handle_rep)
  36. };
  40. class handle_base {
  42. protected:
  44. handle_rep* PTR;
  46. public:
  48.  handle_base() {}
  49.  handle_base(const handle_base& x) { PTR = x.PTR;  PTR->count++; }
  50. ~handle_base() { if (PTR && --PTR->count == 0)  delete PTR;}
  52. handle_base& operator=(const handle_base& x)
  53. { x.PTR->count++;
  54.   if (PTR && --PTR->count == 0)  delete PTR; // left side may be 0
  55.   PTR = x.PTR;
  56.   return *this;
  57.  }
  59. int    refs()  const { return PTR->count; }
  62. friend unsigned long ID_Number(const handle_base& x)
  63. { return (unsigned long)x.PTR; }
  65. friend bool identical(const handle_base& x, const handle_base& y)
  66. { return x.PTR == y.PTR; }
  69. #if !defined(__EXPLICIT_DESTRUCTION__)
  70. void  clear() { if (PTR && --PTR->count == 0) delete PTR; }
  71. friend void explicit_destruction(handle_base* p) {  p->clear(); }
  72. #endif
  75. #if !defined(__TEMPLATE_FUNCTIONS__)
  76.  
  77. // without function templates we define  Copy,Convert,Clear, ..
  78. // functions valid for all handle types derived from handle_base
  79.  
  80. GenPtr copy() const { PTR->count++; return PTR; }
  81. GenPtr conv() const { return PTR; }
  82. void   clear() { if (PTR && --PTR->count == 0) delete PTR; }
  83.  
  84. friend inline GenPtr Copy(const handle_base&);
  85. friend inline GenPtr Convert(const handle_base&);
  86. friend inline void   Clear(handle_base&);
  87. friend inline int    compare(const handle_base&, const handle_base&);
  88. friend inline int    Hash(const handle_base&);
  89. friend inline void   Print(const handle_base&, ostream&);
  90. friend inline void   Read(handle_base&, istream&);
  91.  
  92. #endif
  94.  
  95. };
  98.  
  100. #if !defined(__TEMPLATE_FUNCTIONS__)
  101.  
  102. inline GenPtr Copy(const handle_base& x)    { return x.copy(); }
  103. inline GenPtr Convert(const handle_base& x) { return x.conv(); }
  104. inline void   Clear(handle_base& x)         { x.clear(); }
  105.  
  106. inline int compare(const handle_base& x, const handle_base& y)
  107. { return compare(x.PTR, y.PTR); }
  108.  
  109. inline int  Hash(const handle_base& x)               { return *(int*)x.PTR; }
  110. inline void Print(const handle_base& x, ostream& os) { Print(x,os); }
  111. inline void Read(handle_base& x, istream& is)        { Read(x,is); }
  112.  
  113. #endif
  116. #define LEDA_HANDLE_TYPE(T)  /* historical, not used  anymore */
  117.  
  118.  
  119. #endif
  120.