mirror of
https://git.dev.opencascade.org/repos/occt.git
synced 2025-04-03 17:56:21 +03:00
0024023: Revamp the OCCT Handle -- handle
Macro defining Handle class is replaced by template class implementing the same concept (defined in Standard_Handle.hxx and Standard_Transient.hxx), opencascade::handle<>. Header file Standard_DefineHandle.hxx becomes deprecated: the only useful macro DEFINE_STANDARD_RTTI is defined now in Standard_Type.hxx. Standard_DefineHandle.hxx is kept for compatibility, it defines macros previously used for definition of Handles and RTTI as empty. Macro DEFINE_STANDARD_HANDLE(C1,C2) is also kept for compatibility; now it expands to typedef "Handle_C1" to corresponding handle class. Definitions of macro Handle() and STANDARD_TYPE() moved from Standard_Macro.hxx to Standard_Handle.hxx (new file) and Standard_Type.hxx, respectively. New template class NCollection_Shared added, allowing to define sub-class manipulated by handle, for any non-transient class. Adaptations for compiling with GCC 4.7
This commit is contained in:
abv
parent
e35db4162b
commit
e7195ab476
@ -72,7 +72,6 @@ NCollection_SparseArrayBase.cxx
|
||||
NCollection_CellFilter.hxx
|
||||
NCollection_CellFilterNDim.hxx
|
||||
NCollection_Handle.hxx
|
||||
NCollection_Handle.cxx
|
||||
|
||||
NCollection_Comparator.hxx
|
||||
NCollection_QuickSort.hxx
|
||||
@ -88,3 +87,4 @@ NCollection_Vec4.hxx
|
||||
NCollection_Mat4.hxx
|
||||
|
||||
NCollection_StlIterator.hxx
|
||||
NCollection_Shared.hxx
|
||||
|
||||
@ -25,7 +25,6 @@
|
||||
// Declaration of Sequence class managed by Handle
|
||||
|
||||
#define DEFINE_HSEQUENCE(HClassName, _SequenceType_) \
|
||||
DEFINE_STANDARD_HANDLE (HClassName, MMgt_TShared) \
|
||||
class HClassName : public _SequenceType_, public MMgt_TShared { \
|
||||
public: \
|
||||
DEFINE_STANDARD_ALLOC \
|
||||
@ -44,7 +43,8 @@ class HClassName : public _SequenceType_, public MMgt_TShared { \
|
||||
_SequenceType_::Append (theOther->ChangeSequence()); \
|
||||
} \
|
||||
DEFINE_STANDARD_RTTI (HClassName, MMgt_TShared) \
|
||||
};
|
||||
}; \
|
||||
DEFINE_STANDARD_HANDLE (HClassName, MMgt_TShared)
|
||||
|
||||
#define IMPLEMENT_HSEQUENCE(HClassName)
|
||||
|
||||
|
||||
@ -1,16 +0,0 @@
|
||||
// Created on: 2009-01-30
|
||||
// Created by: Andrey BETENEV (abv)
|
||||
// Copyright (c) 2009-2014 OPEN CASCADE SAS
|
||||
//
|
||||
// This file is part of Open CASCADE Technology software library.
|
||||
//
|
||||
// This library is free software; you can redistribute it and/or modify it under
|
||||
// the terms of the GNU Lesser General Public License version 2.1 as published
|
||||
// by the Free Software Foundation, with special exception defined in the file
|
||||
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
|
||||
// distribution for complete text of the license and disclaimer of any warranty.
|
||||
//
|
||||
// Alternatively, this file may be used under the terms of Open CASCADE
|
||||
// commercial license or contractual agreement.
|
||||
|
||||
#include <NCollection_Handle.hxx>
|
||||
@ -74,17 +74,23 @@ class NCollection_Handle : public Handle(Standard_Transient)
|
||||
: Handle(Standard_Transient) (theObject ? new Ptr (theObject) : 0) {}
|
||||
|
||||
//! Cast handle to contained type
|
||||
T* operator -> () { return ((Ptr*)ControlAccess())->myPtr; }
|
||||
T* get () { return ((Ptr*)Handle(Standard_Transient)::get())->myPtr; }
|
||||
|
||||
//! Cast handle to contained type
|
||||
const T* get () const { return ((Ptr*)Handle(Standard_Transient)::get())->myPtr; }
|
||||
|
||||
//! Cast handle to contained type
|
||||
T* operator -> () { return get(); }
|
||||
|
||||
//! Cast handle to contained type
|
||||
const T* operator -> () const { return ((Ptr*)ControlAccess())->myPtr; }
|
||||
const T* operator -> () const { return get(); }
|
||||
|
||||
//! Cast handle to contained type
|
||||
T& operator * () { return *((Ptr*)ControlAccess())->myPtr; }
|
||||
T& operator * () { return *get(); }
|
||||
|
||||
//! Cast handle to contained type
|
||||
const T& operator * () const { return *((Ptr*)ControlAccess())->myPtr; }
|
||||
|
||||
const T& operator * () const { return *get(); }
|
||||
|
||||
//! Downcast arbitrary Handle to the argument type if contained
|
||||
//! object is Handle for this type; returns null otherwise
|
||||
static NCollection_Handle<T> DownCast (const Handle(Standard_Transient)& theOther)
|
||||
|
||||
62
src/NCollection/NCollection_Shared.hxx
Normal file
62
src/NCollection/NCollection_Shared.hxx
Normal file
@ -0,0 +1,62 @@
|
||||
// Created on: 2015-06-26
|
||||
// Created by: Andrey Betenev
|
||||
// Copyright (c) 2015 OPEN CASCADE SAS
|
||||
//
|
||||
// This file is part of Open CASCADE Technology software library.
|
||||
//
|
||||
// This library is free software; you can redistribute it and/or modify it under
|
||||
// the terms of the GNU Lesser General Public License version 2.1 as published
|
||||
// by the Free Software Foundation, with special exception defined in the file
|
||||
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
|
||||
// distribution for complete text of the license and disclaimer of any warranty.
|
||||
//
|
||||
// Alternatively, this file may be used under the terms of Open CASCADE
|
||||
// commercial license or contractual agreement.
|
||||
|
||||
#ifndef NCollection_Shared_HeaderFile
|
||||
#define NCollection_Shared_HeaderFile
|
||||
|
||||
#include <Standard_Type.hxx>
|
||||
|
||||
//! Template defining a class derived from the specified base class and
|
||||
//! Standard_Transient, and supporting OCCT RTTI.
|
||||
//!
|
||||
//! This provides possibility to use Handes for types not initially intended
|
||||
//! to be dynamically allocated.
|
||||
//!
|
||||
//! Current limitation is that only copy and constructors with 1-3 arguments are defined,
|
||||
//! calling those of the argument class (default constructor must be available).
|
||||
//! It can be improved when perfect forwarding of template arguments is supported
|
||||
//! by all compilers used for OCCT.
|
||||
//!
|
||||
//! The intent is similar to std::make_shared<> in STL, except that this
|
||||
//! implementation defines a separate type.
|
||||
|
||||
template <class T, typename = typename std::enable_if<! std::is_base_of<Standard_Transient, T>::value>::type>
|
||||
class NCollection_Shared : public Standard_Transient, public T
|
||||
{
|
||||
public:
|
||||
DEFINE_STANDARD_ALLOC
|
||||
DEFINE_NCOLLECTION_ALLOC
|
||||
|
||||
//! Default constructor
|
||||
NCollection_Shared () {}
|
||||
|
||||
//! Constructor with single argument
|
||||
template <typename T1>
|
||||
NCollection_Shared (T1 arg1) : T(arg1) {}
|
||||
|
||||
//! Constructor with two arguments
|
||||
template <typename T1, typename T2>
|
||||
NCollection_Shared (T1 arg1, T2 arg2) : T(arg1, arg2) {}
|
||||
|
||||
/* this could work...
|
||||
//! Forwarding constructor
|
||||
template<typename... Args>
|
||||
NCollection_Shared (Args&&... args)
|
||||
: T (std::forward<Args>(args)...)
|
||||
{}
|
||||
*/
|
||||
};
|
||||
|
||||
#endif
|
||||
@ -11,10 +11,6 @@ Standard_JmpBuf.hxx
|
||||
Standard_CMPLRS.edl
|
||||
Standard_Copy.tcl
|
||||
Standard_WOKSteps.edl
|
||||
Handle_Standard_Persistent.hxx
|
||||
Handle_Standard_Persistent.cxx
|
||||
Handle_Standard_Transient.cxx
|
||||
Handle_Standard_Transient.hxx
|
||||
Standard_Address.hxx
|
||||
Standard_Boolean.hxx
|
||||
Standard_Byte.hxx
|
||||
@ -27,12 +23,12 @@ Standard_Character.hxx
|
||||
Standard_ExtCharacter.hxx
|
||||
Standard_ExtString.cxx
|
||||
Standard_ExtString.hxx
|
||||
Standard_HashCode.cxx
|
||||
Standard_Handle.hxx
|
||||
Standard_IStream.hxx
|
||||
Standard_Integer.hxx
|
||||
Standard_Macro.hxx
|
||||
Standard_OStream.hxx
|
||||
Standard_Persistent_proto.hxx
|
||||
Standard_Persistent.hxx
|
||||
Standard_PrimitiveTypes.hxx
|
||||
Standard_Real.cxx
|
||||
Standard_Real.hxx
|
||||
@ -43,8 +39,6 @@ Standard_ShortReal.hxx
|
||||
Standard_Stream.hxx
|
||||
Standard_Time.hxx
|
||||
Standard_Transient.hxx
|
||||
Standard_Transient.cxx
|
||||
Standard_Transient_proto.hxx
|
||||
Standard_TypeDef.hxx
|
||||
Standard_Type.hxx
|
||||
Standard_Type.cxx
|
||||
|
||||
@ -1,16 +0,0 @@
|
||||
// Copyright (c) 1998-1999 Matra Datavision
|
||||
// Copyright (c) 1999-2014 OPEN CASCADE SAS
|
||||
//
|
||||
// This file is part of Open CASCADE Technology software library.
|
||||
//
|
||||
// This library is free software; you can redistribute it and/or modify it under
|
||||
// the terms of the GNU Lesser General Public License version 2.1 as published
|
||||
// by the Free Software Foundation, with special exception defined in the file
|
||||
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
|
||||
// distribution for complete text of the license and disclaimer of any warranty.
|
||||
//
|
||||
// Alternatively, this file may be used under the terms of Open CASCADE
|
||||
// commercial license or contractual agreement.
|
||||
|
||||
#include <Standard_Persistent.hxx>
|
||||
|
||||
@ -1,30 +0,0 @@
|
||||
// Copyright (c) 1998-1999 Matra Datavision
|
||||
// Copyright (c) 1999-2014 OPEN CASCADE SAS
|
||||
//
|
||||
// This file is part of Open CASCADE Technology software library.
|
||||
//
|
||||
// This library is free software; you can redistribute it and/or modify it under
|
||||
// the terms of the GNU Lesser General Public License version 2.1 as published
|
||||
// by the Free Software Foundation, with special exception defined in the file
|
||||
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
|
||||
// distribution for complete text of the license and disclaimer of any warranty.
|
||||
//
|
||||
// Alternatively, this file may be used under the terms of Open CASCADE
|
||||
// commercial license or contractual agreement.
|
||||
|
||||
//============================================================================
|
||||
// Title : Handle_Standard_Persistent.hxx
|
||||
// Role : This file just include <Standard_Persistent.hxx>
|
||||
//============================================================================
|
||||
|
||||
#ifndef _Handle_Standard_Persistent_HeaderFile
|
||||
#define _Handle_Standard_Persistent_HeaderFile
|
||||
|
||||
#include <Standard_DefineHandle.hxx>
|
||||
#include <Standard_Persistent_proto.hxx>
|
||||
|
||||
DEFINE_STANDARD_HANDLE(Standard_Persistent, Standard_Transient)
|
||||
|
||||
Standard_EXPORT Standard_Integer HashCode(const Handle(Standard_Persistent)&, const Standard_Integer);
|
||||
|
||||
#endif
|
||||
@ -1,55 +0,0 @@
|
||||
// Copyright (c) 1998-1999 Matra Datavision
|
||||
// Copyright (c) 1999-2014 OPEN CASCADE SAS
|
||||
//
|
||||
// This file is part of Open CASCADE Technology software library.
|
||||
//
|
||||
// This library is free software; you can redistribute it and/or modify it under
|
||||
// the terms of the GNU Lesser General Public License version 2.1 as published
|
||||
// by the Free Software Foundation, with special exception defined in the file
|
||||
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
|
||||
// distribution for complete text of the license and disclaimer of any warranty.
|
||||
//
|
||||
// Alternatively, this file may be used under the terms of Open CASCADE
|
||||
// commercial license or contractual agreement.
|
||||
|
||||
#include <Standard_Transient.hxx>
|
||||
#include <Standard_Atomic.hxx>
|
||||
|
||||
//============================================================================
|
||||
|
||||
void Handle(Standard_Transient)::Dump(Standard_OStream& out) const
|
||||
{
|
||||
out << Access();
|
||||
}
|
||||
|
||||
//============================================================================
|
||||
|
||||
void Handle(Standard_Transient)::Assign (const Standard_Transient *anItem)
|
||||
{
|
||||
Standard_Transient *anIt = (Standard_Transient*)anItem;
|
||||
if ( anIt == entity ) return;
|
||||
EndScope();
|
||||
entity = anIt;
|
||||
BeginScope();
|
||||
}
|
||||
|
||||
//============================================================================
|
||||
|
||||
void Handle(Standard_Transient)::BeginScope()
|
||||
{
|
||||
if (entity != 0)
|
||||
{
|
||||
Standard_Atomic_Increment (&entity->count);
|
||||
}
|
||||
}
|
||||
|
||||
//============================================================================
|
||||
|
||||
void Handle(Standard_Transient)::EndScope()
|
||||
{
|
||||
if (entity == 0)
|
||||
return;
|
||||
if (Standard_Atomic_Decrement (&entity->count) == 0)
|
||||
entity->Delete();
|
||||
entity = 0;
|
||||
}
|
||||
@ -1,238 +0,0 @@
|
||||
// Copyright (c) 1998-1999 Matra Datavision
|
||||
// Copyright (c) 1999-2014 OPEN CASCADE SAS
|
||||
//
|
||||
// This file is part of Open CASCADE Technology software library.
|
||||
//
|
||||
// This library is free software; you can redistribute it and/or modify it under
|
||||
// the terms of the GNU Lesser General Public License version 2.1 as published
|
||||
// by the Free Software Foundation, with special exception defined in the file
|
||||
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
|
||||
// distribution for complete text of the license and disclaimer of any warranty.
|
||||
//
|
||||
// Alternatively, this file may be used under the terms of Open CASCADE
|
||||
// commercial license or contractual agreement.
|
||||
|
||||
#ifndef _Handle_Standard_Transient_HeaderFile
|
||||
#define _Handle_Standard_Transient_HeaderFile
|
||||
|
||||
#include <Standard.hxx>
|
||||
#include <Standard_DefineAlloc.hxx>
|
||||
#include <Standard_PrimitiveTypes.hxx>
|
||||
#include <Standard_Transient_proto.hxx>
|
||||
|
||||
#ifdef _WIN32
|
||||
// Disable the warning "conversion from 'unsigned int' to Standard_Transient *"
|
||||
#pragma warning (push)
|
||||
#pragma warning (disable:4312)
|
||||
#endif
|
||||
|
||||
class Handle_Standard_Transient;
|
||||
|
||||
Standard_EXPORT Standard_Integer HashCode(const Handle(Standard_Transient)& ,const Standard_Integer);
|
||||
|
||||
/**
|
||||
* Base class for hierarchy of smart pointers (Handles) for Transient
|
||||
* objects. Uses reference counting technique to control life time
|
||||
* of the referred object.
|
||||
*
|
||||
* Note that Handle should never be initialized by pointer to object
|
||||
* created in the stack; only dinamically allocated pointers shall be used.
|
||||
*/
|
||||
|
||||
class Handle(Standard_Transient)
|
||||
{
|
||||
public:
|
||||
|
||||
// Public methods
|
||||
|
||||
//! Empty constructor
|
||||
Handle(Standard_Transient) ()
|
||||
: entity(0)
|
||||
{
|
||||
}
|
||||
|
||||
//! Constructor from pointer to new object
|
||||
Handle(Standard_Transient) (const Standard_Transient *anItem)
|
||||
: entity ( (Standard_Transient*)anItem )
|
||||
{
|
||||
BeginScope();
|
||||
}
|
||||
|
||||
//! Copy constructor
|
||||
Handle(Standard_Transient) (const Handle(Standard_Transient)& aTid)
|
||||
: entity ( aTid.entity )
|
||||
{
|
||||
BeginScope();
|
||||
}
|
||||
|
||||
//! Destructor
|
||||
~Handle(Standard_Transient)()
|
||||
{
|
||||
EndScope();
|
||||
}
|
||||
|
||||
//! Assignment operator
|
||||
Handle(Standard_Transient)& operator=(const Handle(Standard_Transient)& aHandle)
|
||||
{
|
||||
Assign(aHandle.Access());
|
||||
return *this;
|
||||
}
|
||||
|
||||
//! Assignment operator
|
||||
Handle(Standard_Transient)& operator=(const Standard_Transient* anItem)
|
||||
{
|
||||
Assign(anItem);
|
||||
return *this;
|
||||
}
|
||||
|
||||
//! Nullify the handle
|
||||
void Nullify()
|
||||
{
|
||||
EndScope();
|
||||
}
|
||||
|
||||
//! Check for being null
|
||||
Standard_Boolean IsNull() const
|
||||
{
|
||||
return entity == 0;
|
||||
}
|
||||
|
||||
//! Returns pointer to referred object
|
||||
Standard_Transient* Access()
|
||||
{
|
||||
return entity;
|
||||
}
|
||||
|
||||
//! Returns const pointer to referred object
|
||||
const Standard_Transient* Access() const
|
||||
{
|
||||
return entity;
|
||||
}
|
||||
|
||||
//! Cast to pointer to referred object
|
||||
operator Standard_Transient*()
|
||||
{
|
||||
return entity;
|
||||
}
|
||||
|
||||
//! Cast to const pointer to referred object
|
||||
operator const Standard_Transient*() const
|
||||
{
|
||||
return entity;
|
||||
}
|
||||
|
||||
//! Member access operator (note non-const)
|
||||
Standard_Transient* operator->() const
|
||||
{
|
||||
return entity;
|
||||
}
|
||||
|
||||
//! STL-style member accessor
|
||||
Standard_Transient* get() const
|
||||
{
|
||||
return entity;
|
||||
}
|
||||
|
||||
//! Dereferencing operator
|
||||
Standard_Transient& operator*()
|
||||
{
|
||||
return *entity;
|
||||
}
|
||||
|
||||
//! Const dereferencing operator
|
||||
const Standard_Transient& operator*() const
|
||||
{
|
||||
return *entity;
|
||||
}
|
||||
|
||||
//! Check for equality
|
||||
int operator==(const Handle(Standard_Transient)& right) const
|
||||
{
|
||||
return entity == right.entity;
|
||||
}
|
||||
|
||||
//! Check for equality
|
||||
int operator==(const Standard_Transient *right) const
|
||||
{
|
||||
return entity == right;
|
||||
}
|
||||
|
||||
//! Check for equality
|
||||
friend bool operator==(const Standard_Transient *left, const Handle(Standard_Transient)& right)
|
||||
{
|
||||
return left == right.entity;
|
||||
}
|
||||
|
||||
//! Check for inequality
|
||||
bool operator!=(const Handle(Standard_Transient)& right) const
|
||||
{
|
||||
return entity != right.entity;
|
||||
}
|
||||
|
||||
//! Check for inequality
|
||||
bool operator!=(const Standard_Transient *right) const
|
||||
{
|
||||
return entity != right;
|
||||
}
|
||||
|
||||
//! Check for inequality
|
||||
friend bool operator!=(const Standard_Transient *left, const Handle(Standard_Transient)& right)
|
||||
{
|
||||
return left != right.entity;
|
||||
}
|
||||
|
||||
//! Down casting operator; dummy provided for consistency with other classes
|
||||
//! (descendants)
|
||||
static const Handle(Standard_Transient)& DownCast(const Handle(Standard_Transient)& AnObject)
|
||||
{
|
||||
return AnObject;
|
||||
}
|
||||
|
||||
//! Dump pointer to a referred object to a stream
|
||||
Standard_EXPORT void Dump(Standard_OStream& out) const;
|
||||
|
||||
protected:
|
||||
// Protected methods for descendants
|
||||
|
||||
//! Returns non-const pointer to referred object
|
||||
Standard_Transient* ControlAccess() const
|
||||
{
|
||||
return entity;
|
||||
}
|
||||
|
||||
//! Assignment
|
||||
Standard_EXPORT void Assign (const Standard_Transient *anItem);
|
||||
|
||||
private:
|
||||
// Private methods
|
||||
|
||||
//! Increment reference counter of referred object
|
||||
Standard_EXPORT void BeginScope();
|
||||
|
||||
//! Decrement reference counter and if 0, destroy referred object
|
||||
Standard_EXPORT void EndScope();
|
||||
|
||||
public:
|
||||
|
||||
DEFINE_STANDARD_ALLOC
|
||||
|
||||
private:
|
||||
// Field
|
||||
Standard_Transient *entity;
|
||||
};
|
||||
|
||||
//! Function in global scope to check handles for equality.
|
||||
//! Will be used with standard OCCT collections like NCollection_DataMap within NCollection_DefaultHasher
|
||||
//! when there are no specialization defined for concrete type.
|
||||
//! Notice that this implementation compares only pointers to objects!
|
||||
inline Standard_Boolean IsEqual (const Handle(Standard_Transient)& theFirst,
|
||||
const Handle(Standard_Transient)& theSecond)
|
||||
{
|
||||
return theFirst == theSecond;
|
||||
}
|
||||
|
||||
#ifdef _WIN32
|
||||
#pragma warning (pop)
|
||||
#endif
|
||||
|
||||
#endif
|
||||
@ -65,7 +65,7 @@ is
|
||||
|
||||
class GUID;
|
||||
|
||||
deferred class Persistent ;
|
||||
imported deferred class Persistent ;
|
||||
|
||||
imported deferred class Transient ;
|
||||
imported transient class Type; -- inherits Transient
|
||||
|
||||
@ -25,8 +25,6 @@ proc Standard_Copy:HandleInputFile { ID } {
|
||||
scan $ID "%\[^:\]:%\[^:\]:%\[^:\]" unit type name
|
||||
|
||||
switch $name {
|
||||
Handle_Standard_Transient.hxx {return 1;}
|
||||
Handle_Standard_Persistent.hxx {return 1;}
|
||||
Standard_Transient.hxx {return 1;}
|
||||
Standard_Persistent.hxx {return 1;}
|
||||
default {
|
||||
@ -42,20 +40,10 @@ proc Standard_Copy:Execute { unit args } {
|
||||
foreach file $args {
|
||||
scan $file "%\[^:\]:%\[^:\]:%\[^:\]" Unit type name
|
||||
|
||||
set source [woklocate -p Standard:source:$name [wokinfo -N $unit]]
|
||||
|
||||
if { $name == "Standard_Persistent.hxx" || $name == "Standard_Persistent_objy.ddl"} {
|
||||
set source [woklocate -p Standard:source:Standard_Persistent_proto.hxx [wokinfo -N $unit]]
|
||||
} else {
|
||||
set source [woklocate -p Standard:source:$name [wokinfo -N $unit]]
|
||||
}
|
||||
|
||||
if { $name == "lctlprt.dll" || $name == "lctlprt.lib" || $name == "lmgr32.dll" || $name == "rtk.lib" || $name == "rtk.dll" } {
|
||||
set vistarget [woklocate -p Standard:library:$name [wokinfo -N $unit]]
|
||||
set target [wokinfo -p library:$name $unit]
|
||||
} else {
|
||||
set vistarget [woklocate -p Standard:pubinclude:$name [wokinfo -N $unit]]
|
||||
set target [wokinfo -p pubinclude:$name $unit]
|
||||
}
|
||||
set vistarget [woklocate -p Standard:pubinclude:$name [wokinfo -N $unit]]
|
||||
set target [wokinfo -p pubinclude:$name $unit]
|
||||
|
||||
if { [catch {eval exec "cmp $source $vistarget"} ] } {
|
||||
msgprint -i -c "Standard_Copy::Execute" "Copy $source to $target"
|
||||
|
||||
@ -15,76 +15,17 @@
|
||||
#ifndef _Standard_DefineHandle_HeaderFile
|
||||
#define _Standard_DefineHandle_HeaderFile
|
||||
|
||||
#include <Standard_Macro.hxx>
|
||||
|
||||
//! @file
|
||||
//! This file provides low-level helper macros for definition of OCCT handles and types.
|
||||
//! It is not to be included in the user code directly; include Standard_Type.hxx instead.
|
||||
//! This file provides obsolete low-level helper macros used to define OCCT handles and types,
|
||||
//! for compatibility with previous versions of OCCT.
|
||||
//! Since OCCT 7.0, relevant macros are provided by Standard_Type.hxx and Standard_Handle.hxx.
|
||||
|
||||
#include <Standard_Type.hxx>
|
||||
|
||||
class Standard_Transient;
|
||||
class Standard_Persistent;
|
||||
class Standard_Type;
|
||||
|
||||
// Forward declarations of auxiliary template class for type descriptor instantiation
|
||||
// and down casting function; defined in Standard_Type.hxx
|
||||
namespace opencascade {
|
||||
template <typename T> class type_instance;
|
||||
template <class H1, class H2> H1 down_cast (const H2& theObject);
|
||||
}
|
||||
|
||||
//! Helper macro to get instance of a type descriptor for a class in a legacy way.
|
||||
#define STANDARD_TYPE(theType) Standard_Type::Instance<theType>()
|
||||
|
||||
//! Helper macro to be included in definition of the classes inheriting
|
||||
//! Standard_Transient to enable use of OCCT RTTI and smart pointers (handles).
|
||||
#define DEFINE_STANDARD_RTTI(Class,Base) \
|
||||
public: \
|
||||
typedef Base base_type; \
|
||||
static const char* get_type_name () { return #Class; } \
|
||||
virtual const Handle(Standard_Type)& DynamicType() const { return STANDARD_TYPE(Class); }
|
||||
|
||||
//! Define OCCT Handle for a class C1 inheriting C2,
|
||||
//! with BC being a root of the hierarchy
|
||||
#define DEFINE_STANDARD_HANDLECLASS(C1,C2,BC) \
|
||||
class C1; \
|
||||
class Handle(C1) : public Handle(C2) { \
|
||||
public: \
|
||||
typedef C1 element_type;\
|
||||
\
|
||||
Handle(C1)() {} \
|
||||
Handle(C1)(const Handle(C1)& aHandle) : Handle(C2)(aHandle) {} \
|
||||
Handle(C1)(const C1* anItem) : Handle(C2)((C2 *)anItem) {} \
|
||||
\
|
||||
Handle(C1)& operator=(const Handle(C1)& aHandle) \
|
||||
{ \
|
||||
Assign(aHandle.Access()); \
|
||||
return *this; \
|
||||
} \
|
||||
Handle(C1)& operator=(const C1* anItem) \
|
||||
{ \
|
||||
Assign((BC*)anItem); \
|
||||
return *this; \
|
||||
} \
|
||||
\
|
||||
C1& operator*() const { return *(C1 *)ControlAccess(); } \
|
||||
C1* operator->() const { return (C1 *)ControlAccess(); } \
|
||||
C1* get() const { return (C1 *)ControlAccess(); } \
|
||||
\
|
||||
template <class HBC> \
|
||||
static Handle(C1) DownCast(const HBC& theObject) \
|
||||
{ \
|
||||
return opencascade::down_cast <Handle(C1), HBC> (theObject); \
|
||||
} \
|
||||
};
|
||||
|
||||
// TRANSIENT
|
||||
//
|
||||
#define DEFINE_STANDARD_HANDLE(C1,C2) DEFINE_STANDARD_HANDLECLASS(C1,C2,Standard_Transient)
|
||||
|
||||
// PERSISTENT
|
||||
//
|
||||
#define DEFINE_STANDARD_PHANDLE(C1,C2) DEFINE_STANDARD_HANDLECLASS(C1,C2,Standard_Persistent)
|
||||
|
||||
// Obsolete macros kept for compatibility
|
||||
#define IMPLEMENT_DOWNCAST(C1,BC)
|
||||
#define IMPLEMENT_STANDARD_HANDLE(C1,C2)
|
||||
|
||||
267
src/Standard/Standard_Handle.hxx
Normal file
267
src/Standard/Standard_Handle.hxx
Normal file
@ -0,0 +1,267 @@
|
||||
// Copyright (c) 2014 OPEN CASCADE SAS
|
||||
//
|
||||
// This file is part of Open CASCADE Technology software library.
|
||||
//
|
||||
// This library is free software; you can redistribute it and/or modify it under
|
||||
// the terms of the GNU Lesser General Public License version 2.1 as published
|
||||
// by the Free Software Foundation, with special exception defined in the file
|
||||
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
|
||||
// distribution for complete text of the license and disclaimer of any warranty.
|
||||
//
|
||||
// Alternatively, this file may be used under the terms of Open CASCADE
|
||||
// commercial license or contractual agreement.
|
||||
|
||||
#ifndef _Standard_Handle_HeaderFile
|
||||
#define _Standard_Handle_HeaderFile
|
||||
|
||||
#include <Standard_Address.hxx>
|
||||
#include <Standard_Stream.hxx>
|
||||
#include <Standard_Transient.hxx>
|
||||
|
||||
#include <type_traits>
|
||||
|
||||
class Standard_Transient;
|
||||
|
||||
namespace opencascade {
|
||||
|
||||
//! Intrusive smart pointer for use with Standard_Transient class and its descendants.
|
||||
//!
|
||||
//! This class is similar to boost::intrusive_ptr<>, with additional
|
||||
//! feature historically supported by Handles in OCCT:
|
||||
//! it has type conversion to const reference to handle to the base types,
|
||||
//! which allows it to be passed by reference
|
||||
//! in functions accepring reference to handle to base class.
|
||||
template <class T>
|
||||
class handle
|
||||
{
|
||||
public:
|
||||
//! STL-compliant typedef of contained type
|
||||
typedef T element_type;
|
||||
|
||||
public:
|
||||
|
||||
//! Empty constructor
|
||||
handle () : entity(0) {}
|
||||
|
||||
//! Constructor from pointer to new object
|
||||
handle (const T *thePtr) : entity(const_cast<T*>(thePtr))
|
||||
{
|
||||
BeginScope();
|
||||
}
|
||||
/* TODO: uncomment and remove const from method above
|
||||
//! Constructor from const pointer to new object;
|
||||
//! will raise exception if object's reference counter is zero
|
||||
explicit handle (const T *thePtr) : entity(thePtr->This())
|
||||
{
|
||||
BeginScope();
|
||||
}
|
||||
*/
|
||||
//! Copy constructor
|
||||
handle (const handle& theHandle) : entity(theHandle.entity)
|
||||
{
|
||||
BeginScope();
|
||||
}
|
||||
|
||||
//! Destructor
|
||||
~handle ()
|
||||
{
|
||||
EndScope();
|
||||
}
|
||||
|
||||
//! Nullify the handle
|
||||
void Nullify()
|
||||
{
|
||||
EndScope();
|
||||
}
|
||||
|
||||
//! Check for being null
|
||||
bool IsNull() const { return entity == 0; }
|
||||
|
||||
//! Reset by new pointer
|
||||
void reset (T* thePtr)
|
||||
{
|
||||
Assign (thePtr);
|
||||
}
|
||||
|
||||
//! Assignment operator
|
||||
handle& operator= (const handle& theHandle)
|
||||
{
|
||||
Assign (theHandle.entity);
|
||||
return *this;
|
||||
}
|
||||
|
||||
//! Assignment to pointer
|
||||
handle& operator= (const T* thePtr)
|
||||
{
|
||||
Assign (const_cast<T*>(thePtr));
|
||||
return *this;
|
||||
}
|
||||
/* uncomment along with constructor
|
||||
//! Assignment to pointer to const object
|
||||
handle& operator= (const T* thePtr)
|
||||
{
|
||||
Assign (thePtr->This());
|
||||
return *this;
|
||||
}
|
||||
*/
|
||||
//! STL-like cast to pointer to referred object
|
||||
const T* get () const { return static_cast<const T*>(this->entity); }
|
||||
|
||||
//! STL-like cast to pointer to referred object
|
||||
T* get () { return static_cast<T*>(this->entity); }
|
||||
|
||||
//! Member access operator (note non-const)
|
||||
T* operator-> () const { return static_cast<T*>(this->entity); }
|
||||
|
||||
//! Dereferencing operator
|
||||
T& operator* () { return *get(); }
|
||||
|
||||
//! Const dereferencing operator
|
||||
const T& operator*() const { return *get(); }
|
||||
|
||||
//! Check for equality
|
||||
template <class T2>
|
||||
bool operator== (const handle<T2>& theHandle) const
|
||||
{
|
||||
return this->entity == theHandle.entity;
|
||||
}
|
||||
|
||||
//! Check for equality
|
||||
bool operator== (const Standard_Transient *thePtr) const
|
||||
{
|
||||
return this->entity == thePtr;
|
||||
}
|
||||
|
||||
//! Check for equality
|
||||
friend bool operator== (const Standard_Transient *left, const handle& right)
|
||||
{
|
||||
return left == right.entity;
|
||||
}
|
||||
|
||||
//! Check for inequality
|
||||
template <class T2>
|
||||
bool operator!= (const handle<T2>& theHandle) const
|
||||
{
|
||||
return this->entity != theHandle.entity;
|
||||
}
|
||||
|
||||
//! Check for inequality
|
||||
bool operator!= (const Standard_Transient *thePtr) const
|
||||
{
|
||||
return this->entity != thePtr;
|
||||
}
|
||||
|
||||
//! Check for inequality
|
||||
friend bool operator!= (const Standard_Transient *left, const handle& right)
|
||||
{
|
||||
return left != right.entity;
|
||||
}
|
||||
|
||||
//! Down casting operator
|
||||
template <class T2>
|
||||
static handle DownCast (const handle<T2>& theObject)
|
||||
{
|
||||
return handle (dynamic_cast<T*>(const_cast<T2*>(theObject.get())));
|
||||
}
|
||||
|
||||
//! Down casting operator
|
||||
template <class T2>
|
||||
static handle DownCast (const T2* thePtr)
|
||||
{
|
||||
return handle (dynamic_cast<T*>(const_cast<T2*>(thePtr)));
|
||||
}
|
||||
|
||||
#if __cplusplus >= 201103L || (defined(_MSC_VER) && _MSC_VER >= 1800) || (defined(__GNUC__) && __GNUC__ >= 4 && __GNUC_MINOR__ >= 3)
|
||||
|
||||
//! Upcast to const reference to base type.
|
||||
template <class T2, typename = typename std::enable_if<std::is_base_of<T2, T>::value>::type>
|
||||
operator const handle<T2>& () const
|
||||
{
|
||||
return reinterpret_cast<const handle<T2>&>(*this);
|
||||
}
|
||||
|
||||
//! Upcast to non-const reference to base type.
|
||||
//! NB: this cast can be dangerous, see #26377
|
||||
template <class T2, typename = typename std::enable_if<std::is_base_of<T2, T>::value>::type>
|
||||
operator handle<T2>& ()
|
||||
{
|
||||
return reinterpret_cast<handle<T2>&>(*this);
|
||||
}
|
||||
|
||||
#else /* fallback version for compilers not supporting default arguments of function templates (VC10, VC11, GCC below 4.3) */
|
||||
|
||||
//! Upcast to const reference to base type.
|
||||
//! NB: this implementation will cause ambiguity errors on calls to overloaded
|
||||
//! functions accepting handles to different types, since compatibility is
|
||||
//! checked in the cast code rather than ensured by SFINAE (possible with C++11)
|
||||
template <class T2>
|
||||
operator const handle<T2>& () const
|
||||
{
|
||||
// error "type is not a member of enable_if" will be generated if T2 is not sub-type of T
|
||||
// (handle is being cast to const& to handle of non-base type)
|
||||
return reinterpret_cast<typename std::enable_if<std::is_base_of<T2, T>::value, const handle<T2>&>::type>(*this);
|
||||
}
|
||||
|
||||
//! Upcast to non-const reference to base type.
|
||||
//! NB: this cast can be dangerous, see #26377
|
||||
template <class T2>
|
||||
operator handle<T2>& ()
|
||||
{
|
||||
// error "type is not a member of enable_if" will be generated if T2 is not sub-type of T
|
||||
// (handle is being cast to const& to handle of non-base type)
|
||||
return reinterpret_cast<typename std::enable_if<std::is_base_of<T2, T>::value, handle<T2>&>::type>(*this);
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
private:
|
||||
|
||||
//! Assignment
|
||||
void Assign (Standard_Transient *thePtr)
|
||||
{
|
||||
if (thePtr == entity)
|
||||
return;
|
||||
EndScope();
|
||||
entity = thePtr;
|
||||
BeginScope();
|
||||
}
|
||||
|
||||
//! Increment reference counter of referred object
|
||||
void BeginScope()
|
||||
{
|
||||
if (entity != 0)
|
||||
entity->IncrementRefCounter();
|
||||
}
|
||||
|
||||
//! Decrement reference counter and if 0, destroy referred object
|
||||
void EndScope()
|
||||
{
|
||||
if (entity != 0 && entity->DecrementRefCounter() == 0)
|
||||
entity->Delete();
|
||||
entity = 0;
|
||||
}
|
||||
|
||||
template <class T2> friend class handle;
|
||||
|
||||
private:
|
||||
Standard_Transient* entity;
|
||||
};
|
||||
|
||||
} // namespace opencascade
|
||||
|
||||
//! Define Handle() macro
|
||||
#define Handle(Class) opencascade::handle<Class>
|
||||
|
||||
//! Global method HashCode(), for use in hash maps
|
||||
template <class T>
|
||||
inline Standard_Integer HashCode (const Handle(T)& theHandle, const Standard_Integer theUpper)
|
||||
{
|
||||
return ::HashCode (const_cast<Standard_Address>(static_cast<const void*>(theHandle.get())), theUpper);
|
||||
}
|
||||
|
||||
//! For compatibility with previous versions of OCCT, defines typedef opencascade::handle<Class> Handle_Class
|
||||
#define DEFINE_STANDARD_HANDLECLASS(C1,C2,BC) typedef Handle(C1) Handle_##C1;
|
||||
#define DEFINE_STANDARD_HANDLE(C1,C2) DEFINE_STANDARD_HANDLECLASS(C1,C2,Standard_Transient)
|
||||
#define DEFINE_STANDARD_PHANDLE(C1,C2) DEFINE_STANDARD_HANDLECLASS(C1,C2,Standard_Persistent)
|
||||
|
||||
#endif
|
||||
@ -1,43 +0,0 @@
|
||||
// Copyright (c) 1998-1999 Matra Datavision
|
||||
// Copyright (c) 1999-2014 OPEN CASCADE SAS
|
||||
//
|
||||
// This file is part of Open CASCADE Technology software library.
|
||||
//
|
||||
// This library is free software; you can redistribute it and/or modify it under
|
||||
// the terms of the GNU Lesser General Public License version 2.1 as published
|
||||
// by the Free Software Foundation, with special exception defined in the file
|
||||
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
|
||||
// distribution for complete text of the license and disclaimer of any warranty.
|
||||
//
|
||||
// Alternatively, this file may be used under the terms of Open CASCADE
|
||||
// commercial license or contractual agreement.
|
||||
|
||||
#include <Standard_Transient.hxx>
|
||||
#include <Standard_Persistent.hxx>
|
||||
#include <Standard_Type.hxx>
|
||||
#include <Standard_RangeError.hxx>
|
||||
|
||||
//============================================================================
|
||||
Standard_EXPORT Standard_Integer HashCode (const Handle(Standard_Transient)& me,
|
||||
const Standard_Integer Upper )
|
||||
{
|
||||
Standard_RangeError_Raise_if (Upper < 1,
|
||||
"Try to apply HashCode method "
|
||||
"with negative or null argument.");
|
||||
|
||||
const Standard_Integer I = (Standard_Integer) ptrdiff_t(me.operator->());
|
||||
return HashCode( I , Upper ) ;
|
||||
}
|
||||
|
||||
//============================================================================
|
||||
Standard_EXPORT Standard_Integer HashCode(const Handle(Standard_Persistent)& me,
|
||||
const Standard_Integer Upper )
|
||||
{
|
||||
Standard_RangeError_Raise_if (Upper < 1,
|
||||
"Try to apply HashCode method "
|
||||
"with negative or null argument.");
|
||||
|
||||
const Standard_Integer I = (Standard_Integer) ptrdiff_t(me.operator->());
|
||||
return HashCode( I , Upper) ;
|
||||
}
|
||||
|
||||
@ -19,9 +19,6 @@
|
||||
#ifndef _Standard_Macro_HeaderFile
|
||||
# define _Standard_Macro_HeaderFile
|
||||
|
||||
// Standard OCC macros: Handle(), STANDARD_TYPE()
|
||||
# define Handle(ClassName) Handle_##ClassName
|
||||
|
||||
#if defined(__cplusplus) && (__cplusplus >= 201100L)
|
||||
// part of C++11 standard
|
||||
#define Standard_OVERRIDE override
|
||||
|
||||
@ -14,108 +14,19 @@
|
||||
-- Alternatively, this file may be used under the terms of Open CASCADE
|
||||
-- commercial license or contractual agreement.
|
||||
|
||||
deferred class Persistent from Standard
|
||||
imported deferred class Persistent from Standard
|
||||
inherits Transient from Standard
|
||||
|
||||
---Purpose:
|
||||
-- The root of the entire persistent class hierarchy.
|
||||
--
|
||||
-- Persistence is the ability to create objects which
|
||||
-- outlive the application process.
|
||||
-- Objects stored in the database must be instances
|
||||
-- of a Persistent-derived class.
|
||||
-- The collection of persistent classes used by an
|
||||
-- application constitute its application data schema.
|
||||
--
|
||||
-- Open CASCADE provides persistent classes to describe:
|
||||
-- - ASCII (normal 8 bit character type) and
|
||||
-- Unicode (16 bit character type) strings,
|
||||
-- - arrays of persistent data,
|
||||
-- - geometric data structures,
|
||||
-- - topological data structures.
|
||||
--
|
||||
-- The user can enrich this set of persistent classes by describing
|
||||
-- his own persistent data structures inheriting from Persistent
|
||||
-- for use in a store and retrieve programming context.
|
||||
--
|
||||
-- Warning:
|
||||
--
|
||||
-- Persistent objects are manipulated in programs by handles.
|
||||
-- A handle to a persistent object behaves like
|
||||
-- a pointer to the entire database address space.
|
||||
-- In using such a handle, you transparently operate on the object
|
||||
-- in the database, providing that you do this inside a transaction.
|
||||
--
|
||||
-- However "Persistent Programming" (i.e. the programming
|
||||
-- technique whereby the application operates on persistent
|
||||
-- objects, that is, directly in the database, within a transaction)
|
||||
-- is not supported by Open CASCADE.
|
||||
|
||||
uses
|
||||
Type from Standard
|
||||
,Boolean from Standard
|
||||
,OId from Standard
|
||||
|
||||
uses
|
||||
Transient
|
||||
|
||||
---Purpose:
|
||||
-- Root of "persistent" classes, a legacy support of
|
||||
-- object oriented databases, now outdated.
|
||||
|
||||
is
|
||||
|
||||
Delete (me: mutable) is virtual;
|
||||
---Purpose: Deletes this object.
|
||||
|
||||
|
||||
DynamicType (me) returns Type is virtual;
|
||||
---Purpose:
|
||||
-- Returns the type object representing the actual type of the object.
|
||||
-- There is one type object per Persistent-derived class.
|
||||
--
|
||||
-- Example:
|
||||
--
|
||||
-- Handle(Standard_Persistent) p;
|
||||
-- Handle(Standard_Type) t;
|
||||
-- p = new PGeom_CartesianPoint(0.,0.,0.);
|
||||
-- t = STANDARD_TYPE(PGeom_CartesianPoint);
|
||||
-- assert(p->DynamicType() == t);
|
||||
|
||||
IsInstance (me; TheType : Type) returns Boolean is static;
|
||||
---Purpose:
|
||||
-- Returns true if the actual type of the object is equal to the given type.
|
||||
--
|
||||
-- Example:
|
||||
--
|
||||
-- Handle(Standard_Persistent) p;
|
||||
-- Handle(Standard_Type) t;
|
||||
-- p = new PGeom_CartesianPoint(0.,0.,0.);
|
||||
-- t = STANDARD_TYPE(PGeom_CartesianPoint);
|
||||
-- assert(p->IsInstance(t));
|
||||
--
|
||||
-- Warning:
|
||||
--
|
||||
-- For most purposes it is better to use IsKind because IsInstance
|
||||
-- rejects objects being subtype of the given type.
|
||||
|
||||
IsKind (me; TheType : Type) returns Boolean
|
||||
---Purpose:
|
||||
-- Returns true if <me> is an instance of <aType> or an
|
||||
-- instance of any class that inherits from <aType>.
|
||||
-- All persistent objects are a kind of Object class.
|
||||
--
|
||||
-- Example:
|
||||
--
|
||||
-- Handle(Standard_Persistent) p;
|
||||
-- Handle(Standard_Type) tp, tt;
|
||||
-- p = new PGeom_CartesianPoint(0.,0.,0.);
|
||||
-- tp = STANDARD_TYPE(PGeom_CartesianPoint);
|
||||
-- tt = STANDARD_TYPE(Standard_Persistent);
|
||||
-- assert(p->IsKind(tp));
|
||||
-- assert(p->IsKind(tt));
|
||||
is static;
|
||||
|
||||
This (me) returns Persistent
|
||||
---Purpose: Returns a handle on the object.
|
||||
-- This method is useful only in constructors of persistent
|
||||
-- objects when you need a handle on the object being constructed.
|
||||
-- It guarantees that, whatever the underlying database
|
||||
-- you are using, the object will not be swapped out
|
||||
-- during its construction.
|
||||
is static protected;
|
||||
Initialize returns Persistent;
|
||||
|
||||
end Persistent from Standard;
|
||||
|
||||
|
||||
@ -12,38 +12,27 @@
|
||||
// Alternatively, this file may be used under the terms of Open CASCADE
|
||||
// commercial license or contractual agreement.
|
||||
|
||||
#ifndef _Standard_Persistent_proto_HeaderFile
|
||||
#define _Standard_Persistent_proto_HeaderFile
|
||||
#ifndef _Standard_Persistent_HeaderFile
|
||||
#define _Standard_Persistent_HeaderFile
|
||||
|
||||
#include <Standard.hxx>
|
||||
#include <Standard_Type.hxx>
|
||||
#include <Standard_OStream.hxx>
|
||||
|
||||
class Standard_Type;
|
||||
class Handle_Standard_Type;
|
||||
class Handle_Standard_Persistent;
|
||||
class Standard_Type;
|
||||
|
||||
class Storage_stCONSTclCOM;
|
||||
|
||||
//! Root of "persistent" classes, a legacy support of
|
||||
//! object oriented databases, now outdated.
|
||||
class Standard_Persistent : public Standard_Transient
|
||||
{
|
||||
friend class Handle(Standard_Persistent);
|
||||
friend class Storage_Schema;
|
||||
public:
|
||||
DEFINE_STANDARD_ALLOC
|
||||
|
||||
Standard_Persistent() : _typenum(0), _refnum(0) {}
|
||||
|
||||
DEFINE_STANDARD_RTTI(Standard_Persistent,Standard_Transient)
|
||||
|
||||
private:
|
||||
Standard_Integer _typenum;
|
||||
Standard_Integer _refnum;
|
||||
public:
|
||||
|
||||
Standard_Persistent& operator= (const Standard_Persistent&) { return *this; }
|
||||
Standard_Persistent() : _typenum(0),_refnum(0) {}
|
||||
Standard_Persistent(const Standard_Persistent&) : _typenum(0),_refnum(0) {}
|
||||
Standard_Persistent(const Storage_stCONSTclCOM&) : _typenum(0),_refnum(0) {}
|
||||
|
||||
DEFINE_STANDARD_RTTI(Standard_Persistent,Standard_Transient)
|
||||
friend class Storage_Schema;
|
||||
};
|
||||
|
||||
#include <Handle_Standard_Persistent.hxx>
|
||||
|
||||
#endif
|
||||
#endif // _Standard_Persistent_HeaderFile
|
||||
@ -12,31 +12,22 @@
|
||||
// Alternatively, this file may be used under the terms of Open CASCADE
|
||||
// commercial license or contractual agreement.
|
||||
|
||||
#include <Standard_Transient.hxx>
|
||||
#include <Standard_Type.hxx>
|
||||
#include <Standard_Transient.hxx>
|
||||
#include <Standard_Atomic.hxx>
|
||||
#include <Standard_CString.hxx>
|
||||
#include <Standard_ProgramError.hxx>
|
||||
|
||||
void Standard_Transient::Delete() const
|
||||
{
|
||||
delete this;
|
||||
}
|
||||
|
||||
//
|
||||
// The Standard_Transient Methods
|
||||
//
|
||||
|
||||
// DynamicType
|
||||
//
|
||||
const Handle(Standard_Type)& Standard_Transient::DynamicType() const
|
||||
{
|
||||
return STANDARD_TYPE(Standard_Transient);
|
||||
}
|
||||
|
||||
// The Method This
|
||||
//
|
||||
Handle(Standard_Transient) Standard_Transient::This() const
|
||||
{
|
||||
return Handle(Standard_Transient)(this);
|
||||
}
|
||||
|
||||
// Empty Destructor
|
||||
//
|
||||
Standard_Transient::~Standard_Transient()
|
||||
{
|
||||
return opencascade::type_instance<Standard_Transient>::get();
|
||||
}
|
||||
|
||||
//
|
||||
@ -67,7 +58,23 @@ Standard_Boolean Standard_Transient::IsKind (const Standard_CString theTypeName)
|
||||
return DynamicType()->SubType ( theTypeName );
|
||||
}
|
||||
|
||||
void Standard_Transient::Delete() const
|
||||
{
|
||||
delete((Standard_Transient *)this);
|
||||
//
|
||||
//
|
||||
Standard_Transient* Standard_Transient::This() const
|
||||
{
|
||||
if (GetRefCount() == 0)
|
||||
Standard_ProgramError::Raise ("Attempt to create handle to object created in stack, not yet constructed, or destroyed");
|
||||
return const_cast<Standard_Transient*> (this);
|
||||
}
|
||||
|
||||
// Increment reference counter
|
||||
void Standard_Transient::IncrementRefCounter() const
|
||||
{
|
||||
Standard_Atomic_Increment (&count);
|
||||
}
|
||||
|
||||
// Decrement reference counter
|
||||
Standard_Integer Standard_Transient::DecrementRefCounter() const
|
||||
{
|
||||
return Standard_Atomic_Decrement (&count);
|
||||
}
|
||||
|
||||
@ -15,9 +15,100 @@
|
||||
#ifndef _Standard_Transient_HeaderFile
|
||||
#define _Standard_Transient_HeaderFile
|
||||
|
||||
#include <Handle_Standard_Transient.hxx>
|
||||
#include <Standard.hxx>
|
||||
#include <Standard_DefineAlloc.hxx>
|
||||
#include <Standard_PrimitiveTypes.hxx>
|
||||
#include <Standard_Transient_proto.hxx>
|
||||
//#include <Standard_Type.hxx>
|
||||
|
||||
class Standard_Type;
|
||||
|
||||
namespace opencascade {
|
||||
template <class T> class handle;
|
||||
}
|
||||
|
||||
//! Abstract class which forms the root of the entire
|
||||
//! Transient class hierarchy.
|
||||
|
||||
class Standard_Transient
|
||||
{
|
||||
public:
|
||||
// Standard OCCT memory allocation stuff
|
||||
DEFINE_STANDARD_ALLOC
|
||||
|
||||
public:
|
||||
|
||||
//! Empty constructor
|
||||
Standard_Transient() : count(0) {}
|
||||
|
||||
//! Copy constructor -- does nothing
|
||||
Standard_Transient (const Standard_Transient&) : count(0) {}
|
||||
|
||||
//! Assignment operator, needed to avoid copying reference counter
|
||||
Standard_Transient& operator= (const Standard_Transient&) { return *this; }
|
||||
|
||||
//! Destructor must be virtual
|
||||
virtual ~Standard_Transient() {}
|
||||
|
||||
//! Memory deallocator for transient classes
|
||||
Standard_EXPORT virtual void Delete() const;
|
||||
|
||||
public:
|
||||
//!@name Support of run-time type information (RTTI)
|
||||
|
||||
typedef void base_type;
|
||||
|
||||
static const char* get_type_name () { return "Standard_Transient"; }
|
||||
|
||||
//! Returns a type information object about this object.
|
||||
Standard_EXPORT virtual const opencascade::handle<Standard_Type>& DynamicType() const;
|
||||
|
||||
//! Returns a true value if this is an instance of Type.
|
||||
Standard_EXPORT Standard_Boolean IsInstance(const opencascade::handle<Standard_Type>& theType) const;
|
||||
|
||||
//! Returns a true value if this is an instance of TypeName.
|
||||
Standard_EXPORT Standard_Boolean IsInstance(const Standard_CString theTypeName) const;
|
||||
|
||||
//! Returns true if this is an instance of Type or an
|
||||
//! instance of any class that inherits from Type.
|
||||
//! Note that multiple inheritance is not supported by OCCT RTTI mechanism.
|
||||
Standard_EXPORT Standard_Boolean IsKind(const opencascade::handle<Standard_Type>& theType) const;
|
||||
|
||||
//! Returns true if this is an instance of TypeName or an
|
||||
//! instance of any class that inherits from TypeName.
|
||||
//! Note that multiple inheritance is not supported by OCCT RTTI mechanism.
|
||||
Standard_EXPORT Standard_Boolean IsKind(const Standard_CString theTypeName) const;
|
||||
|
||||
//! Returns non-const pointer to this object (like const_cast).
|
||||
//! For protection against creating handle to objects allocated in stack
|
||||
//! or call from constructor, it will raise exception Standard_ProgramError
|
||||
//! if reference counter is zero.
|
||||
Standard_EXPORT Standard_Transient* This() const;
|
||||
|
||||
public:
|
||||
//!@name Reference counting, for use by handle<>
|
||||
|
||||
//! Get the reference counter of this object
|
||||
Standard_EXPORT Standard_Integer GetRefCount() const { return count; }
|
||||
|
||||
//! Increments the reference counter of this object
|
||||
Standard_EXPORT void IncrementRefCounter() const;
|
||||
|
||||
//! Decrements the reference counter of this object;
|
||||
//! returns the decremented value
|
||||
Standard_EXPORT Standard_Integer DecrementRefCounter() const;
|
||||
|
||||
private:
|
||||
|
||||
//! Reference counter
|
||||
mutable volatile Standard_Integer count;
|
||||
};
|
||||
|
||||
//! Global method HashCode(), for use in hash maps
|
||||
inline Standard_Integer HashCode (const Standard_Transient* theObject, const Standard_Integer theUpper)
|
||||
{
|
||||
return ::HashCode ((Standard_Address*)theObject, theUpper);
|
||||
}
|
||||
|
||||
//! Definition of Handle_Standard_Transient as typedef for compatibility
|
||||
typedef opencascade::handle<Standard_Transient> Handle_Standard_Transient;
|
||||
|
||||
#endif
|
||||
|
||||
@ -1,92 +0,0 @@
|
||||
// Copyright (c) 1998-1999 Matra Datavision
|
||||
// Copyright (c) 1999-2014 OPEN CASCADE SAS
|
||||
//
|
||||
// This file is part of Open CASCADE Technology software library.
|
||||
//
|
||||
// This library is free software; you can redistribute it and/or modify it under
|
||||
// the terms of the GNU Lesser General Public License version 2.1 as published
|
||||
// by the Free Software Foundation, with special exception defined in the file
|
||||
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
|
||||
// distribution for complete text of the license and disclaimer of any warranty.
|
||||
//
|
||||
// Alternatively, this file may be used under the terms of Open CASCADE
|
||||
// commercial license or contractual agreement.
|
||||
|
||||
#ifndef _Standard_Transient_proto_HeaderFile
|
||||
#define _Standard_Transient_proto_HeaderFile
|
||||
|
||||
#include <Standard_DefineAlloc.hxx>
|
||||
#include <Standard_Macro.hxx>
|
||||
#include <Standard.hxx>
|
||||
|
||||
class Handle_Standard_Transient;
|
||||
class Standard_Type;
|
||||
class Handle_Standard_Type;
|
||||
|
||||
//! Abstract class which forms the root of the entire
|
||||
//! Transient class hierarchy.
|
||||
|
||||
class Standard_Transient
|
||||
{
|
||||
//---- uses the friend Standard_Transient class
|
||||
friend class Handle(Standard_Transient);
|
||||
|
||||
public:
|
||||
|
||||
DEFINE_STANDARD_ALLOC
|
||||
|
||||
//! Definition of base_type for RTTI (see Standard_Type)
|
||||
typedef void base_type;
|
||||
|
||||
//! Definition of the class name
|
||||
static const char* get_type_name () { return "Standard_Transient"; }
|
||||
|
||||
public:
|
||||
|
||||
//! Empty constructor
|
||||
Standard_Transient() : count(0) {}
|
||||
|
||||
//! Copy constructor -- does nothing
|
||||
Standard_Transient(const Standard_Transient&) : count(0) {}
|
||||
|
||||
//! Assignment operator, needed to avoid copying reference counter
|
||||
Standard_Transient& operator= (const Standard_Transient&) { return *this; }
|
||||
|
||||
//! Destructor must be virtual
|
||||
Standard_EXPORT virtual ~Standard_Transient();
|
||||
|
||||
//! Memory deallocator for transient classes
|
||||
Standard_EXPORT virtual void Delete() const;
|
||||
|
||||
//! Returns a type information object about this object.
|
||||
Standard_EXPORT virtual const Handle_Standard_Type& DynamicType() const;
|
||||
|
||||
//! Returns a true value if this is an instance of Type.
|
||||
Standard_EXPORT Standard_Boolean IsInstance(const Handle_Standard_Type& theType) const;
|
||||
|
||||
//! Returns a true value if this is an instance of TypeName.
|
||||
Standard_EXPORT Standard_Boolean IsInstance(const Standard_CString theTypeName) const;
|
||||
|
||||
//! Returns true if this is an instance of Type or an
|
||||
//! instance of any class that inherits from Type.
|
||||
//! Note that multiple inheritance is not supported by OCCT RTTI mechanism.
|
||||
Standard_EXPORT Standard_Boolean IsKind(const Handle_Standard_Type& theType) const;
|
||||
|
||||
//! Returns true if this is an instance of TypeName or an
|
||||
//! instance of any class that inherits from TypeName.
|
||||
//! Note that multiple inheritance is not supported by OCCT RTTI mechanism.
|
||||
Standard_EXPORT Standard_Boolean IsKind(const Standard_CString theTypeName) const;
|
||||
|
||||
//! Returns a Handle which references this object.
|
||||
//! Must never be called to objects created in stack.
|
||||
Standard_EXPORT virtual Handle_Standard_Transient This() const;
|
||||
|
||||
//! Get the reference counter of this object.
|
||||
Standard_EXPORT Standard_Integer GetRefCount() const { return count; }
|
||||
|
||||
private:
|
||||
|
||||
volatile Standard_Integer count;
|
||||
};
|
||||
|
||||
#endif
|
||||
@ -71,8 +71,8 @@ namespace {
|
||||
}
|
||||
}
|
||||
|
||||
const Standard_Type* Standard_Type::Register (const char* theSystemName, const char* theName,
|
||||
Standard_Size theSize, const Handle(Standard_Type)& theParent)
|
||||
Standard_Type* Standard_Type::Register (const char* theSystemName, const char* theName,
|
||||
Standard_Size theSize, const Handle(Standard_Type)& theParent)
|
||||
{
|
||||
// Access to registry is protected by mutex; it should not happen often because
|
||||
// instances are cached by Standard_Type::Instance() (one per binary module)
|
||||
|
||||
@ -16,13 +16,28 @@
|
||||
#define _Standard_Type_HeaderFile
|
||||
|
||||
#include <Standard.hxx>
|
||||
#include <Standard_DefineHandle.hxx>
|
||||
#include <Standard_Handle.hxx>
|
||||
#include <Standard_Transient.hxx>
|
||||
#include <Standard_OStream.hxx>
|
||||
|
||||
#include <typeinfo>
|
||||
|
||||
// Define handle class
|
||||
DEFINE_STANDARD_HANDLE(Standard_Type, Standard_Transient)
|
||||
//! Helper macro to get instance of a type descriptor for a class in a legacy way.
|
||||
#define STANDARD_TYPE(theType) Standard_Type::Instance<theType>()
|
||||
|
||||
//! Helper macro to be included in definition of the classes inheriting
|
||||
//! Standard_Transient to enable use of OCCT RTTI and smart pointers (handles).
|
||||
#define DEFINE_STANDARD_RTTI(Class,Base) \
|
||||
public: \
|
||||
typedef Base base_type; \
|
||||
static const char* get_type_name () { return #Class; } \
|
||||
virtual const Handle(Standard_Type)& DynamicType() const { return STANDARD_TYPE(Class); }
|
||||
|
||||
// forward declaration of type_instance class
|
||||
namespace opencascade {
|
||||
template <typename T>
|
||||
class type_instance;
|
||||
}
|
||||
|
||||
//! This class provides legacy interface (type descriptor) to run-time type
|
||||
//! information (RTTI) for OCCT classes inheriting from Standard_Transient.
|
||||
@ -94,8 +109,8 @@ public:
|
||||
//!
|
||||
//! Note that this function is intended for use by opencascade::type_instance only.
|
||||
Standard_EXPORT static
|
||||
const Standard_Type* Register (const char* theSystemName, const char* theName,
|
||||
Standard_Size theSize, const Handle(Standard_Type)& theParent);
|
||||
Standard_Type* Register (const char* theSystemName, const char* theName,
|
||||
Standard_Size theSize, const Handle(Standard_Type)& theParent);
|
||||
|
||||
//! Destructor removes the type from the registry
|
||||
Standard_EXPORT ~Standard_Type ();
|
||||
@ -160,17 +175,6 @@ namespace opencascade {
|
||||
template <typename T>
|
||||
Handle(Standard_Type) type_instance<T>::myInstance (get());
|
||||
|
||||
//! Definition of dynamic cast function for handles
|
||||
template <class H1, class H2>
|
||||
H1 down_cast (const H2& theObject)
|
||||
{
|
||||
return ! theObject.IsNull() && theObject->IsKind (Standard_Type::Instance<typename H1::element_type>()) ?
|
||||
static_cast<typename H1::element_type*> (theObject.get()) : 0;
|
||||
/* alternative implementation using standard C++ RTTI is slower:
|
||||
return dynamic_cast<typename H1::element_type*>(theObject.get());
|
||||
*/
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
//! Operator printing type descriptor to stream
|
||||
@ -180,4 +184,7 @@ inline Standard_OStream& operator << (Standard_OStream& theStream, const Handle(
|
||||
return theStream;
|
||||
}
|
||||
|
||||
//! Definition of Handle_Standard_Type as typedef for compatibility
|
||||
DEFINE_STANDARD_HANDLE(Standard_Type,Standard_Transient)
|
||||
|
||||
#endif // _Standard_Type_HeaderFile
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user