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

src/OpenFOAM/memory/tmpNrc/tmpNrc.H

+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  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
+
+// ************************************************************************* //

src/OpenFOAM/memory/tmpNrc/tmpNrcI.H

+/*--------------------------------------------------------------------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;
+}
+
+
+// ************************************************************************* //