File size: 6,087 Bytes
5a600cf | 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 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 | /*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Copyright (C) 2011-2026 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
OpenFOAM is free software: you can redistribute it and/or modify it
under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
OpenFOAM 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 General Public License
for more details.
You should have received a copy of the GNU General Public License
along with OpenFOAM. If not, see <http://www.gnu.org/licenses/>.
Class
Foam::tmp
Description
A class for managing temporary objects
SourceFiles
tmpI.H
See also
Foam::refCount
Foam::autoPtr
\*---------------------------------------------------------------------------*/
#ifndef tmp_H
#define tmp_H
#include "refCount.H"
#include "word.H"
#include "expressionExpressionable.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
/*---------------------------------------------------------------------------*\
Class tmp Declaration
\*---------------------------------------------------------------------------*/
template<class T>
class tmp
{
// Private Data
//- Object types
enum type
{
REUSABLE_TMP,
NON_RESUSABLE_TMP,
CONST_REF
};
//- Type of object
type type_;
//- Pointer to object
mutable T* ptr_;
// Private Member Functions
//- Return true if the object is a reusable or non-reusable temporary
inline bool isAnyTmp() const;
// Private Member Operators
//- Increment the reference count
inline void operator++();
public:
// Public Type Definitions
//- The type
typedef T Type;
//- The reference counting class
typedef Foam::refCount refCount;
// Constructors
//- Store object pointer of a non-reusable or reusable temporary object
inline explicit tmp(T* = 0, bool nonReusable = false);
//- Store object const reference
inline tmp(const T&);
//- Construct copy and increment reference count
inline tmp(const tmp<T>&);
//- Construct copy moving content, does not increment reference count
inline tmp(tmp<T>&&);
//- Construct copy moving content, does not increment reference count
inline tmp(const tmp<T>&&);
//- Construct copy transferring content of temporary if required
inline tmp(const tmp<T>&, bool allowTransfer);
//- Construct from an expression
template<class Expression, class = EnableIfExpression<Expression>>
inline tmp(const Expression& e);
//- Destructor. Deletes temporary object when the reference count is 0.
inline ~tmp();
// Member Functions
// Access
//- Return true if this is really a temporary object
inline bool isTmp() const;
//- Return true if this temporary object empty,
// ie, a temporary without allocation
inline bool empty() const;
//- Is this temporary object valid,
// ie, it is a reference or a temporary that has been allocated
inline bool valid() const;
//- Return the type name of the tmp
// constructed from the type name of T
inline word typeName() const;
// Edit
//- Return non-const reference or generate a fatal error
// if the object is const.
inline T& ref() const;
//- Return tmp pointer for reuse.
// Returns a clone if the object is not a temporary
inline T* ptr() const;
//- If object pointer points to valid object:
// delete object and set pointer to nullptr
inline void clear() const;
// Member Operators
#ifdef NON_CONST_TMP
//- Deprecated non-const dereference operator.
// Use ref() where non-const access is required
inline T& operator()();
#endif
//- Const dereference operator
inline const T& operator()() const;
//- Const cast to the underlying type reference
inline operator const T&() const;
//- Return object pointer
inline T* operator->();
//- Return const object pointer
inline const T* operator->() const;
//- Assignment to pointer changing this tmp to a temporary T
inline void operator=(T*);
//- Assignment transferring the temporary T to this tmp
inline void operator=(const tmp<T>&);
//- Move assignment transferring the temporary T to this tmp
inline void operator=(tmp<T>&&);
//- Move assignment transferring the temporary T to this tmp
inline void operator=(const tmp<T>&&);
};
namespace expression
{
template<class Type>
struct Expressionable<tmp<Type>>
:
public NotExpressionable<Type>
{};
}
template<class T>
Ostream& operator<<(Ostream& os, const tmp<T>& t);
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#include "tmpI.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //
|