/usr/include/libwildmagic/Wm5SmartPointer.h is in libwildmagic-dev 5.13-1ubuntu1.
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 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 | // Geometric Tools, LLC
// Copyright (c) 1998-2014
// Distributed under the Boost Software License, Version 1.0.
// http://www.boost.org/LICENSE_1_0.txt
// http://www.geometrictools.com/License/Boost/LICENSE_1_0.txt
//
// File Version: 5.0.1 (2010/10/01)
#ifndef WM5SMARTPOINTER_H
#define WM5SMARTPOINTER_H
#include "Wm5CoreLIB.h"
#include "Wm5Memory.h"
// The PointerD<T> supports sharing of objects of type T dynamically allocated
// using the Wild Magic memory manager 'newD' operator, where D is dimension
// (0, 1, 2, etc). T should be an object type, not a pointer type. For
// dimension 0, the T-object can also be allocated using the 'new' operator.
// For dimension 1, the T-object-array can also be allocated using the 'new[]'
// operator. For dimensions D >= 2, you must use 'newD', whether those from
// the Wild Magic memory manager or those implemented to use 'new[]'; see the
// Memory class for such implementations. The class does not support sharing
// of stack-based objects; that is, do not pass the address of T-objects on
// the stack.
namespace Wm5
{
//----------------------------------------------------------------------------
class PointerBase
{
protected:
// The map key (void*) is the address of the shared object. The map
// value (int) is the number of references.
typedef std::map<void*,int> ReferenceMap;
typedef ReferenceMap::iterator RMIterator;
typedef ReferenceMap::const_iterator RMCIterator;
WM5_CORE_ITEM static ReferenceMap msMap;
WM5_CORE_ITEM static Mutex msMutex;
};
//----------------------------------------------------------------------------
template <typename T>
class Pointer0 : public PointerBase
{
public:
// Construction and destruction.
Pointer0 (T* data = 0);
Pointer0 (const Pointer0& pointer);
~Pointer0 ();
// Implicit conversions.
inline operator T* () const;
inline T& operator* () const;
inline T* operator-> () const;
// Assignment.
Pointer0& operator= (T* data);
Pointer0& operator= (const Pointer0& pointer);
// Comparisons.
inline bool operator== (T* data) const;
inline bool operator!= (T* data) const;
inline bool operator== (const Pointer0& pointer) const;
inline bool operator!= (const Pointer0& pointer) const;
protected:
T* mData;
};
//----------------------------------------------------------------------------
template <typename T>
class Pointer1 : public PointerBase
{
public:
// Construction and destruction.
Pointer1 (T* data = 0);
Pointer1 (const Pointer1& pointer);
~Pointer1 ();
// Implicit conversions.
inline operator T* () const;
inline T& operator* () const;
inline T* operator-> () const;
// Assignment.
Pointer1& operator= (T* data);
Pointer1& operator= (const Pointer1& pointer);
// Comparisons.
inline bool operator== (T* data) const;
inline bool operator!= (T* data) const;
inline bool operator== (const Pointer1& pointer) const;
inline bool operator!= (const Pointer1& pointer) const;
protected:
T* mData;
};
//----------------------------------------------------------------------------
template <typename T>
class Pointer2 : public PointerBase
{
public:
// Construction and destruction.
Pointer2 (T** data = 0);
Pointer2 (const Pointer2& pointer);
~Pointer2 ();
// Implicit conversions.
inline operator T** () const;
inline T*& operator* () const;
// Assignment.
Pointer2& operator= (T** data);
Pointer2& operator= (const Pointer2& pointer);
// Comparisons.
inline bool operator== (T** data) const;
inline bool operator!= (T** data) const;
inline bool operator== (const Pointer2& pointer) const;
inline bool operator!= (const Pointer2& pointer) const;
protected:
T** mData;
};
//----------------------------------------------------------------------------
template <typename T>
class Pointer3 : public PointerBase
{
public:
// Construction and destruction.
Pointer3 (T*** data = 0);
Pointer3 (const Pointer3& pointer);
~Pointer3 ();
// Implicit conversions.
inline operator T*** () const;
inline T**& operator* () const;
// Assignment.
Pointer3& operator= (T*** data);
Pointer3& operator= (const Pointer3& pointer);
// Comparisons.
inline bool operator== (T*** data) const;
inline bool operator!= (T*** data) const;
inline bool operator== (const Pointer3& pointer) const;
inline bool operator!= (const Pointer3& pointer) const;
protected:
T*** mData;
};
//----------------------------------------------------------------------------
template <typename T>
class Pointer4 : public PointerBase
{
public:
// Construction and destruction.
Pointer4 (T**** data = 0);
Pointer4 (const Pointer4& pointer);
~Pointer4 ();
// Implicit conversions.
inline operator T**** () const;
inline T***& operator* () const;
// Assignment.
Pointer4& operator= (T**** data);
Pointer4& operator= (const Pointer4& pointer);
// Comparisons.
inline bool operator== (T**** data) const;
inline bool operator!= (T**** data) const;
inline bool operator== (const Pointer4& pointer) const;
inline bool operator!= (const Pointer4& pointer) const;
protected:
T**** mData;
};
//----------------------------------------------------------------------------
#include "Wm5SmartPointer.inl"
}
#endif
|