/usr/include/oce/Standard_StdAllocator.hxx is in liboce-foundation-dev 0.15-4.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 | // Author: Roman Lygin, 2011.
// This file is put into Public Domain and thus can freely be used for any purpose.
// The author disclaims any rights and liabilities.
#ifndef _Standard_StdAllocator_HeaderFile
#define _Standard_StdAllocator_HeaderFile
#include <Standard.hxx>
//! Implements allocator requirements as defined in ISO C++ Standard 2003, section 20.1.5.
/*! The allocator uses Open CASCADE Technology memory management API (
Standard::Allocate() and Standard::Free()). It can be used with standard
containers (std::vector, std::map, etc) to use centralized Open CASCADE
memory management and hence decrease memory footprint and/or increase
performance.
Example of use:
\code
std::vector<TopoDS_Shape, Standard_StdAllocator<TopoDS_Shape> > aVec;
TopoDS_Solid aSolid = BRepPrimAPI_MakeBox (10., 20., 30.);
aVec.push_back (aSolid);
\endcode
*/
template<typename T>
class Standard_StdAllocator {
public:
typedef T value_type;
typedef value_type* pointer;
typedef const value_type* const_pointer;
typedef value_type& reference;
typedef const value_type& const_reference;
typedef size_t size_type;
typedef ptrdiff_t difference_type;
template<typename U> struct rebind {
typedef Standard_StdAllocator<U> other;
};
//! Constructor.
/*! Creates an empty object.*/
Standard_StdAllocator() throw() {}
//! Constructor.
/*! Creates an empty object.*/
Standard_StdAllocator( const Standard_StdAllocator& ) throw() {}
//! Destructor.
/*! Empty implementation.*/
~Standard_StdAllocator() throw() {}
//! Constructor.
/*! Creates an empty object.*/
template<typename U> Standard_StdAllocator( const Standard_StdAllocator<U>& ) throw() {}
//! Returns an object address.
/*! Returns &x.*/
pointer address( reference x ) const { return &x; }
//! Returns an object address.
/*! Returns &x.*/
const_pointer address( const_reference x ) const { return &x; }
//! Allocates memory for \a n objects.
/*! Uses Standard::Allocate().*/
pointer allocate( size_type n, const void* /*hint*/ = 0 )
{ return pointer( Standard::Allocate( n * sizeof( value_type ))); }
//! Frees previously allocated memory.
/*! Uses Standard::Free().*/
void deallocate( pointer p, size_type )
{
Standard_Address a = p;
Standard::Free (a); //Standard::Free() requires Standard_Address&
}
//! Returns the largest value for which method allocate might succeed.
size_type max_size() const throw()
{
size_type aMax = static_cast<size_type>( -1 ) / sizeof( value_type );
return (aMax > 0 ? aMax : 1);
}
//! Constructs an object.
/*! Uses the placement new operator and copy constructor to construct an object.*/
void construct( pointer p, const_reference val )
{ new( static_cast<void*>( p )) value_type( val ); }
//! Destroys the object.
/*! Uses object destructor.*/
/* Destructor name must match the class name for __BORLANDC__.*/
#ifdef __BORLANDC__
void destroy( pointer p ) { p->~T(); }
#else
void destroy( pointer p ) { p->~value_type(); }
#endif
};
//! Implements specialization Standard_StdAllocator<void>.
/*! Specialization is similar to std::allocator<void>, as defined in ISO C++
Standard 2003, section 20.4.1.
This specialization is interchangeable with other ones.
Example of use:
\code
std::vector<TopoDS_Shape, Standard_StdAllocator<void> > aVec;
TopoDS_Solid aSolid = BRepPrimAPI_MakeBox (10., 20., 30.);
aVec.push_back (aSolid);
\endcode
*/
template<>
class Standard_StdAllocator<void> {
public:
typedef void* pointer;
typedef const void* const_pointer;
typedef void value_type;
template<typename U> struct rebind {
typedef Standard_StdAllocator<U> other;
};
};
template<typename T, typename U>
inline bool operator==( const Standard_StdAllocator<T>&, const Standard_StdAllocator<U>& )
{ return true; }
template<typename T, typename U>
inline bool operator!=( const Standard_StdAllocator<T>&, const Standard_StdAllocator<U>& )
{ return false; }
#endif
|