src/Standard/Handle_Standard_Transient.hxx

   1 // Copyright (c) 1998-1999 Matra Datavision
   2 // Copyright (c) 1999-2014 OPEN CASCADE SAS
   3 //
   4 // This file is part of Open CASCADE Technology software library.
   5 //
   6 // This library is free software; you can redistribute it and / or modify it
   7 // under the terms of the GNU Lesser General Public version 2.1 as published
   8 // by the Free Software Foundation, with special exception defined in the file
   9 // OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
  10 // distribution for complete text of the license and disclaimer of any warranty.
  11 //
  12 // Alternatively, this file may be used under the terms of Open CASCADE
  13 // commercial license or contractual agreement.
  14
  15 #ifndef _Handle_Standard_Transient_HeaderFile
  16 #define _Handle_Standard_Transient_HeaderFile
  17 #ifndef _Standard_HeaderFile
  18 #include <Standard.hxx>
  19 #endif
  20 #ifndef _Standard_DefineAlloc_HeaderFile
  21 #include <Standard_DefineAlloc.hxx>
  22 #endif
  23 #ifndef _Standard_Macro_HeaderFile
  24 #include <Standard_Macro.hxx>
  25 #endif
  26 #ifndef _Standard_PrimitiveTypes_HeaderFile
  27 #include <Standard_PrimitiveTypes.hxx>
  28 #endif
  29 #ifndef _Standard_Transient_proto_HeaderFile
  30 #include <Standard_Transient_proto.hxx>
  31 #endif
  32
  33 #ifdef _WIN32
  34 // Disable the warning "conversion from 'unsigned int' to Standard_Transient *"
  35 #pragma warning (push)
  36 #pragma warning (disable:4312)
  37 #endif
  38
  39 class Handle_Standard_Transient;
  40
  41 Standard_EXPORT Standard_Integer HashCode(const Handle(Standard_Transient)& ,const Standard_Integer);
  42
  43 /**
  44  * Base class for hierarchy of smart pointers (Handles) for Transient
  45  * objects. Uses reference counting technique to control life time
  46  * of the referred object.
  47  *
  48  * Note that Handle should never be initialized by pointer to object
  49  * created in the stack; only dinamically allocated pointers shall be used.
  50  */
  51
  52 class Handle(Standard_Transient)
  53 {
  54 public:
  55
  56   // Public methods
  57
  58   //! Empty constructor
  59   Handle(Standard_Transient) ()
  60     : entity(0)
  61   {
  62   }
  63
  64   //! Constructor from pointer to new object
  65   Handle(Standard_Transient) (const Standard_Transient *anItem)
  66     : entity ( (Standard_Transient*)anItem )
  67   {
  68     BeginScope();
  69   }
  70
  71   //! Copy constructor
  72   Handle(Standard_Transient) (const Handle(Standard_Transient)& aTid)
  73     : entity ( aTid.entity )
  74   {
  75     BeginScope();
  76   }
  77
  78   //! Destructor
  79   ~Handle(Standard_Transient)()
  80   {
  81     EndScope();
  82   }
  83
  84   //! Assignment operator
  85   Handle(Standard_Transient)& operator=(const Handle(Standard_Transient)& aHandle)
  86   {
  87     Assign(aHandle.Access());
  88     return *this;
  89   }
  90
  91   //! Assignment operator
  92   Handle(Standard_Transient)& operator=(const Standard_Transient* anItem)
  93   {
  94     Assign(anItem);
  95     return *this;
  96   }
  97
  98   //! Nullify the handle
  99   void Nullify()
 100   {
 101     EndScope();
 102   }
 103
 104   //! Check for being null
 105   Standard_Boolean IsNull() const
 106   {
 107     return entity == 0;
 108   }
 109
 110   //! Returns pointer to referred object
 111   Standard_Transient* Access()
 112   {
 113     return entity;
 114   }
 115
 116   //! Returns const pointer to referred object
 117   const Standard_Transient* Access() const
 118   {
 119     return entity;
 120   }
 121
 122   //! Cast to pointer to referred object
 123   operator Standard_Transient*()
 124   {
 125     return entity;
 126   }
 127
 128   //! Cast to const pointer to referred object
 129   operator const Standard_Transient*() const
 130   {
 131     return entity;
 132   }
 133
 134   //! Member access operator (note non-const)
 135   Standard_Transient* operator->() const
 136   {
 137     return entity;
 138   }
 139
 140   //! Dereferencing operator
 141   Standard_Transient& operator*()
 142   {
 143     return *entity;
 144   }
 145
 146   //! Const dereferencing operator
 147   const Standard_Transient& operator*() const
 148   {
 149     return *entity;
 150   }
 151
 152   //! Check for equality
 153   int operator==(const Handle(Standard_Transient)& right) const
 154   {
 155     return entity == right.entity;
 156   }
 157
 158   //! Check for equality
 159   int operator==(const Standard_Transient *right) const
 160   {
 161     return entity == right;
 162   }
 163
 164   //! Check for equality
 165   friend bool operator==(const Standard_Transient *left, const Handle(Standard_Transient)& right)
 166   {
 167     return left == right.entity;
 168   }
 169
 170   //! Check for inequality
 171   bool operator!=(const Handle(Standard_Transient)& right) const
 172   {
 173     return entity != right.entity;
 174   }
 175
 176   //! Check for inequality
 177   bool operator!=(const Standard_Transient *right) const
 178   {
 179     return entity != right;
 180   }
 181
 182   //! Check for inequality
 183   friend bool operator!=(const Standard_Transient *left, const Handle(Standard_Transient)& right)
 184   {
 185     return left != right.entity;
 186   }
 187
 188   //! Down casting operator; dummy provided for consistency with other classes
 189   //! (descendants)
 190   static const Handle(Standard_Transient)& DownCast(const Handle(Standard_Transient)& AnObject)
 191   {
 192     return AnObject;
 193   }
 194
 195   //! Dump pointer to a referred object to a stream
 196   Standard_EXPORT void Dump(Standard_OStream& out) const;
 197
 198 protected:
 199   // Protected methods for descendants
 200
 201   //! Returns non-const pointer to referred object
 202   Standard_Transient* ControlAccess() const
 203   {
 204     return entity;
 205   }
 206
 207   //! Assignment
 208   Standard_EXPORT void Assign (const Standard_Transient *anItem);
 209
 210 private:
 211   // Private methods
 212
 213   //! Increment reference counter of referred object
 214   Standard_EXPORT void BeginScope();
 215
 216   //! Decrement reference counter and if 0, destroy referred object
 217   Standard_EXPORT void EndScope();
 218
 219 public:
 220
 221   DEFINE_STANDARD_ALLOC
 222
 223 private:
 224   // Field
 225   Standard_Transient *entity;
 226 };
 227
 228 //! Function in global scope to check handles for equality.
 229 //! Will be used with standard OCCT collections like NCollection_DataMap within NCollection_DefaultHasher
 230 //! when there are no specialization defined for concrete type.
 231 //! Notice that this implementation compares only pointers to objects!
 232 inline Standard_Boolean IsEqual (const Handle(Standard_Transient)& theFirst,
 233                                  const Handle(Standard_Transient)& theSecond)
 234 {
 235   return theFirst == theSecond;
 236 }
 237
 238 #ifdef _WIN32
 239 #pragma warning (pop)
 240 #endif
 241
 242 #endif