From ce9602e13ae699f8954ead30139f7df898240676 Mon Sep 17 00:00:00 2001 From: ouv Date: Wed, 29 Nov 2006 09:17:38 +0000 Subject: [PATCH] added in text format --- src/VISU_I/SALOME_GenericObjPtr.cc | 126 +++++++++++++++++++++++ src/VISU_I/SALOME_GenericObjPtr.hh | 156 +++++++++++++++++++++++++++++ 2 files changed, 282 insertions(+) create mode 100644 src/VISU_I/SALOME_GenericObjPtr.cc create mode 100644 src/VISU_I/SALOME_GenericObjPtr.hh diff --git a/src/VISU_I/SALOME_GenericObjPtr.cc b/src/VISU_I/SALOME_GenericObjPtr.cc new file mode 100644 index 00000000..6b19648c --- /dev/null +++ b/src/VISU_I/SALOME_GenericObjPtr.cc @@ -0,0 +1,126 @@ +// Copyright (C) 2003 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN, +// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS +// +// This library is free software; you can redistribute it and/or +// modify it under the terms of the GNU Lesser General Public +// License as published by the Free Software Foundation; either +// version 2.1 of the License. +// +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public +// License along with this library; if not, write to the Free Software +// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +// +// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com +// +// +// File : SALOME_GenericObjPtr.cc +// Author : Oleg UVAROV +// Module : SALOME + +#include "SALOME_GenericObjPtr.hh" + +using namespace SALOME; + +//---------------------------------------------------------------------------- +GenericObjPtrBase +::GenericObjPtrBase() : + Object(0) +{ + // Add a reference to the object. + this->Register(); +} + +//---------------------------------------------------------------------------- +GenericObjPtrBase +::GenericObjPtrBase(GenericObj_i* r): + Object(r) +{ + // Add a reference to the object. + this->Register(); +} + +//---------------------------------------------------------------------------- +GenericObjPtrBase +::GenericObjPtrBase(const GenericObjPtrBase& r): + Object(r.Object) +{ + // Add a reference to the object. + this->Register(); +} + +//---------------------------------------------------------------------------- +GenericObjPtrBase +::GenericObjPtrBase(GenericObj_i* r, const GenericObjPtrBase::NoReference&): + Object(r) +{ + // Do not add a reference to the object because we received the + // NoReference argument. +} + +//---------------------------------------------------------------------------- +GenericObjPtrBase +::~GenericObjPtrBase() +{ + // The main pointer must be set to NULL before calling UnRegister, + // so use a local variable to save the pointer. This is because the + // garbage collection reference graph traversal may make it back to + // this smart pointer, and we do not want to include this reference. + if(GenericObj_i* object = this->Object) + { + this->Object = 0; + object->Destroy(); + } +} + +//---------------------------------------------------------------------------- +GenericObjPtrBase& +GenericObjPtrBase +::operator=(GenericObj_i* r) +{ + // This is an exception-safe assignment idiom that also gives the + // correct order of register/unregister calls to all objects + // involved. A temporary is constructed that references the new + // object. Then the main pointer and temporary are swapped and the + // temporary's destructor unreferences the old object. + GenericObjPtrBase(r).Swap(*this); + return *this; +} + +//---------------------------------------------------------------------------- +GenericObjPtrBase& +GenericObjPtrBase +::operator=(const GenericObjPtrBase& r) +{ + // This is an exception-safe assignment idiom that also gives the + // correct order of register/unregister calls to all objects + // involved. A temporary is constructed that references the new + // object. Then the main pointer and temporary are swapped and the + // temporary's destructor unreferences the old object. + GenericObjPtrBase(r).Swap(*this); + return *this; +} + +//---------------------------------------------------------------------------- +void GenericObjPtrBase +::Swap(GenericObjPtrBase& r) +{ + // Just swap the pointers. This is used internally by the + // assignment operator. + GenericObj_i* temp = r.Object; + r.Object = this->Object; + this->Object = temp; +} + +//---------------------------------------------------------------------------- +void GenericObjPtrBase +::Register() +{ + // Add a reference only if the object is not NULL. + if(this->Object) + this->Object->Register(); +} diff --git a/src/VISU_I/SALOME_GenericObjPtr.hh b/src/VISU_I/SALOME_GenericObjPtr.hh new file mode 100644 index 00000000..ecccd2db --- /dev/null +++ b/src/VISU_I/SALOME_GenericObjPtr.hh @@ -0,0 +1,156 @@ +// Copyright (C) 2003 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN, +// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS +// +// This library is free software; you can redistribute it and/or +// modify it under the terms of the GNU Lesser General Public +// License as published by the Free Software Foundation; either +// version 2.1 of the License. +// +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public +// License along with this library; if not, write to the Free Software +// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +// +// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com +// +// +// File : SALOME_GenericObjPtr.hh +// Author : Oleg UVAROV +// Module : SALOME + +#ifndef SALOME_GenericObjPtr_HH +#define SALOME_GenericObjPtr_HH + +#include "SALOME_GenericObj_i.hh" + +namespace SALOME +{ + class GenericObjPtrBase + { + public: + // Description: + // Initialize smart pointer to NULL. + GenericObjPtrBase(); + + // Description: + // Initialize smart pointer to given object. + GenericObjPtrBase( GenericObj_i* ); + + // Description: + // Initialize smart pointer with a new reference to the same object + // referenced by given smart pointer. + GenericObjPtrBase( const GenericObjPtrBase& ); + + // Description: + // Destroy smart pointer and remove the reference to its object. + ~GenericObjPtrBase(); + + // Description: + // Assign object to reference. This removes any reference to an old object. + GenericObjPtrBase& operator=( GenericObj_i* ); + GenericObjPtrBase& operator=( const GenericObjPtrBase& ); + + // Description: + // Get the contained pointer. + GenericObj_i* GetPointer() const + { + return this->Object; + } + + protected: + // Initialize smart pointer to given object, but do not increment + // reference count. The destructor will still decrement the count. + // This effectively makes it an auto-ptr. + class NoReference {}; + GenericObjPtrBase(GenericObj_i* r, const NoReference&); + + // Pointer to the actual object. + GenericObj_i* Object; + + private: + // Internal utility methods. + void Swap( GenericObjPtrBase& ); + void Register(); + }; + + template + class GenericObjPtr: public GenericObjPtrBase + { + public: + // Description: + // Initialize smart pointer to NULL. + GenericObjPtr() {} + + // Description: + // Initialize smart pointer to given object. + GenericObjPtr(T* r): GenericObjPtrBase(r) {} + + // Description: + // Initialize smart pointer with a new reference to the same object + // referenced by given smart pointer. + GenericObjPtr(const GenericObjPtrBase& r): GenericObjPtrBase(r) {} + + // Description: + // Assign object to reference. This removes any reference to an old + // object. + GenericObjPtr& operator=(T* r) + { + this->GenericObjPtrBase::operator=(r); + return *this; + } + + // Description: + // Assign object to reference. This removes any reference to an old + // object. + GenericObjPtr& operator=(const GenericObjPtrBase& r) + { + this->GenericObjPtrBase::operator=(r); + return *this; + } + + // Description: + // Get the contained pointer. + T* GetPointer() const + { + return dynamic_cast(this->Object); + } + + // Description: + // Get the contained pointer. + operator T* () const + { + return dynamic_cast(this->Object); + } + + // Description: + // Dereference the pointer and return a reference to the contained + // object. + T& operator*() const + { + return *dynamic_cast(this->Object); + } + + // Description: + // Provides normal pointer target member access using operator ->. + T* operator->() const + { + return dynamic_cast(this->Object); + } + + // Description: + // Create an instance of an object. + static GenericObjPtr New() + { + return GenericObjPtr(T::New(), NoReference()); + } + + protected: + GenericObjPtr(T* r, const NoReference& n): GenericObjPtrBase(r, n) {} + }; +} + +#endif -- 2.39.2