/usr/include/freefoam/OpenFOAM/Xfer.H is in libfreefoam-dev 0.1.0+dfsg-1build1.
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 192 193 194 195 196 197 198 199 200 201 202 | /*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 1991-2010 OpenCFD Ltd.
\\/ 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::Xfer
Description
A simple container for copying or transferring objects of type \<T\>.
The wrapped object of type \<T\> must implement a transfer() method and
an operator=() copy method.
Since it is decided upon construction of the Xfer object whether the
parameter is to be copied or transferred, the contents of the resulting
Xfer object can be transferred unconditionally. This greatly simplifies
defining constructors or methods in other classes with mixed
transfer/copy semantics without requiring 2^N different versions.
When transferring between dissimilar types, the xferCopyTo() and
xferMoveTo() functions can prove useful. An example is transferring
from a DynamicList to a List. Since the
List\<T\>::transfer(List\<T\>&) method could result in some allocated
memory becoming inaccessible, the xferMoveTo() function should be used to
invoke the correct List\<T\>::transfer(DynamicList\<T\>&) method.
@code
DynamicList<label> dynLst;
...
labelList plainLst( xferMoveTo<labelList>(dynLst) );
@endcode
Of course, since this example is a very common operation, the
DynamicList::xfer() method transfers to a plain List anyhow.
It would thus be simpler (and clearer) just to use the following code:
@code
DynamicList<label> dynLst;
...
labelList plainLst(dynLst.xfer());
@endcode
SeeAlso
xferCopy, xferCopyTo, xferMove, xferMoveTo, xferTmp
SourceFiles
XferI.H
\*---------------------------------------------------------------------------*/
#ifndef Xfer_H
#define Xfer_H
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
// Forward declaration of classes
template<class T> class tmp;
/*---------------------------------------------------------------------------*\
Class Xfer Declaration
\*---------------------------------------------------------------------------*/
template<class T>
class Xfer
{
// Private data
//- Pointer to underlying datatype
mutable T* ptr_;
public:
// Constructors
//- Store object pointer and manage its deletion
// Can also be used later to transfer by assignment
inline explicit Xfer(T* = 0);
//- Construct by copying or by transferring the parameter contents
inline explicit Xfer(T&, bool allowTransfer=false);
//- Construct by copying the parameter contents
inline explicit Xfer(const T&);
//- Construct by transferring the contents
inline Xfer(const Xfer<T>&);
// Destructor
inline ~Xfer();
// Member Functions
//- Return a null object reference
inline static const Xfer<T>& null();
// Member Operators
//- Transfer the contents into the object
inline void operator=(T&);
//- Transfer the contents into the object
inline void operator=(const Xfer<T>&);
//- Reference to the underlying datatype
inline T& operator()() const;
//- Pointer to the underlying datatype
inline T* operator->() const;
};
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
/**
* Construct by copying the contents of the @a arg
*
* @sa xferCopyTo, xferMove, xferMoveTo, xferTmp and Foam::Xfer
*/
template<class T>
inline Xfer<T> xferCopy(const T&);
/**
* Construct by transferring the contents of the @a arg
*
* @sa xferCopy, xferCopyTo, xferMoveTo, xferTmp and Foam::Xfer
*/
template<class T>
inline Xfer<T> xferMove(T&);
/**
* Construct by transferring the contents of the @a arg
*
* @sa xferCopy, xferCopyTo, xferMove, xferMoveTo and Foam::Xfer
*/
template<class T>
inline Xfer<T> xferTmp(Foam::tmp<T>&);
/**
* Construct by copying the contents of the @a arg
* between dissimilar types
*
* @sa xferCopy, xferMove, xferMoveTo, xferTmp and Foam::Xfer
*/
template<class To, class From>
inline Xfer<To> xferCopyTo(const From&);
/**
* Construct by transferring the contents of the @a arg
* between dissimilar types
*
* @par Example Use
* @code
* DynamicList<label> dynLst;
* ...
* labelList plainLst( xferMoveTo<labelList>(dynLst) );
* @endcode
*
* @sa xferCopy, xferCopyTo, xferMove, xferTmp and Foam::Xfer
*/
template<class To, class From>
inline Xfer<To> xferMoveTo(From&);
} // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#include "XferI.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************ vim: set sw=4 sts=4 et: ************************ //
|