Commit 8b9fd564 authored by Henry Weller's avatar Henry Weller
Browse files

OpenFOAM: Added experimental version of 'tmp' which does not use reference counting

parent 7ba41e00
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2016 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::tmpNrc
Description
A class for managing temporary objects without reference counting.
SourceFiles
tmpNrcI.H
SeeAlso
Foam::autoPtr
\*---------------------------------------------------------------------------*/
#ifndef tmpNrc_H
#define tmpNrc_H
#include "word.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
/*---------------------------------------------------------------------------*\
Class tmpNrc Declaration
\*---------------------------------------------------------------------------*/
template<class T>
class tmpNrc
{
// Private data
//- Object types
enum type
{
TMP,
CONST_REF
};
//- Type of object
mutable type type_;
//- Pointer to object
mutable T* ptr_;
public:
// Null reference counter class
class refCount
{
public:
refCount()
{}
};
// Constructors
//- Store object pointer
inline explicit tmpNrc(T* = 0);
//- Store object const reference
inline tmpNrc(const T&);
//- Construct copy and increment reference count
inline tmpNrc(const tmpNrc<T>&);
//- Construct copy transferring content of temporary if required
inline tmpNrc(const tmpNrc<T>&, bool allowTransfer);
//- Destructor: deletes temporary object when the reference count is 0
inline ~tmpNrc();
// 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 tmpNrc
// 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();
//- Return tmpNrc 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 NULL
inline void clear() const;
// Member operators
//- 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 tmpNrc to a temporary T
inline void operator=(T*);
//- Assignment transfering the temporary T to this tmpNrc
inline void operator=(const tmpNrc<T>&);
};
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#include "tmpNrcI.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //
/*--------------------------------------------------------------------r-------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2016 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/>.
\*---------------------------------------------------------------------------*/
#include "error.H"
#include <typeinfo>
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
template<class T>
inline Foam::tmpNrc<T>::tmpNrc(T* tPtr)
:
type_(TMP),
ptr_(tPtr)
{}
template<class T>
inline Foam::tmpNrc<T>::tmpNrc(const T& tRef)
:
type_(CONST_REF),
ptr_(const_cast<T*>(&tRef))
{}
template<class T>
inline Foam::tmpNrc<T>::tmpNrc(const tmpNrc<T>& t)
:
type_(t.type_),
ptr_(t.ptr_)
{
if (isTmp())
{
if (ptr_)
{
t.type_ = CONST_REF;
}
else
{
FatalErrorInFunction
<< "Attempted copy of a deallocated " << typeName()
<< abort(FatalError);
}
}
}
template<class T>
inline Foam::tmpNrc<T>::tmpNrc(const tmpNrc<T>& t, bool allowTransfer)
:
type_(t.type_),
ptr_(t.ptr_)
{
if (isTmp())
{
if (ptr_)
{
if (allowTransfer)
{
t.ptr_ = 0;
}
else
{
t.type_ = CONST_REF;
}
}
else
{
FatalErrorInFunction
<< "Attempted copy of a deallocated " << typeName()
<< abort(FatalError);
}
}
}
template<class T>
inline Foam::tmpNrc<T>::~tmpNrc()
{
clear();
}
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
template<class T>
inline bool Foam::tmpNrc<T>::isTmp() const
{
return type_ == TMP;
}
template<class T>
inline bool Foam::tmpNrc<T>::empty() const
{
return (isTmp() && !ptr_);
}
template<class T>
inline bool Foam::tmpNrc<T>::valid() const
{
return (!isTmp() || (isTmp() && ptr_));
}
template<class T>
inline Foam::word Foam::tmpNrc<T>::typeName() const
{
return "tmpNrc<" + word(typeid(T).name()) + '>';
}
template<class T>
inline T& Foam::tmpNrc<T>::ref()
{
if (isTmp())
{
if (!ptr_)
{
FatalErrorInFunction
<< typeName() << " deallocated"
<< abort(FatalError);
}
}
else
{
FatalErrorInFunction
<< "Attempt to acquire non-const reference to const object"
<< " from a " << typeName()
<< abort(FatalError);
}
return *ptr_;
}
template<class T>
inline T* Foam::tmpNrc<T>::ptr() const
{
if (isTmp())
{
if (!ptr_)
{
FatalErrorInFunction
<< typeName() << " deallocated"
<< abort(FatalError);
}
T* ptr = ptr_;
ptr_ = 0;
return ptr;
}
else
{
return new T(*ptr_);
}
}
template<class T>
inline void Foam::tmpNrc<T>::clear() const
{
if (isTmp() && ptr_)
{
delete ptr_;
ptr_ = 0;
}
}
// * * * * * * * * * * * * * * * Member Operators * * * * * * * * * * * * * //
template<class T>
inline const T& Foam::tmpNrc<T>::operator()() const
{
if (isTmp())
{
if (!ptr_)
{
FatalErrorInFunction
<< typeName() << " deallocated"
<< abort(FatalError);
}
}
// Return const reference
return *ptr_;
}
template<class T>
inline Foam::tmpNrc<T>::operator const T&() const
{
return operator()();
}
template<class T>
inline T* Foam::tmpNrc<T>::operator->()
{
if (isTmp())
{
if (!ptr_)
{
FatalErrorInFunction
<< typeName() << " deallocated"
<< abort(FatalError);
}
}
else
{
FatalErrorInFunction
<< "Attempt to cast const object to non-const for a " << typeName()
<< abort(FatalError);
}
return ptr_;
}
template<class T>
inline const T* Foam::tmpNrc<T>::operator->() const
{
if (isTmp() && !ptr_)
{
FatalErrorInFunction
<< typeName() << " deallocated"
<< abort(FatalError);
}
return ptr_;
}
template<class T>
inline void Foam::tmpNrc<T>::operator=(T* tPtr)
{
clear();
if (!tPtr)
{
FatalErrorInFunction
<< "Attempted copy of a deallocated " << typeName()
<< abort(FatalError);
}
type_ = TMP;
ptr_ = tPtr;
}
template<class T>
inline void Foam::tmpNrc<T>::operator=(const tmpNrc<T>& t)
{
clear();
if (t.isTmp())
{
type_ = TMP;
if (!t.ptr_)
{
FatalErrorInFunction
<< "Attempted assignment to a deallocated " << typeName()
<< abort(FatalError);
}
ptr_ = t.ptr_;
t.ptr_ = 0;
}
else
{
FatalErrorInFunction
<< "Attempted assignment to a const reference to an object"
<< " of type " << typeid(T).name()
<< abort(FatalError);
}
}
//- Return the const reference of the non-const reference argument
template<typename T>
inline const T& Const(T& t)
{
return t;
}
//- Return the const reference of the non-const rvalue reference argument
template<typename T>
inline const T& Const(T&& t)
{
return t;
}
// ************************************************************************* //
Supports Markdown
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment