Commit e56e195a authored by Mark Olesen's avatar Mark Olesen
Browse files

ENH: support objectRegistry store of refPtr (as per tmp)

parent 487002d2
......@@ -42,6 +42,8 @@ SourceFiles
#define regIOobject_H
#include "IOobject.H"
#include "refPtr.H"
#include "tmp.H"
#include "typeInfo.H"
#include "stdFoam.H"
#include "OSspecific.H"
......@@ -52,6 +54,8 @@ SourceFiles
namespace Foam
{
// Forward Declarations
namespace functionEntries
{
class codeStream;
......@@ -59,7 +63,6 @@ namespace functionEntries
namespace fileOperations
{
class uncollatedFileOperation;
class masterUncollatedFileOperation;
}
/*---------------------------------------------------------------------------*\
......@@ -118,11 +121,9 @@ private:
public:
//- Declare friendship with classes that need access to
//- masterOnlyReading
//- Friendship with classes needing access to masterOnlyReading
friend class functionEntries::codeStream;
friend class fileOperations::uncollatedFileOperation;
friend class fileOperations::masterUncollatedFileOperation;
// Static data
......@@ -184,41 +185,46 @@ public:
// \return true if now ownedByRegistry
inline bool store();
//- Register object pointer with its registry
//- and transfer ownership to the registry.
// \return reference to the object.
//- Transfer pointer ownership to its registry.
// \return reference to the stored object
template<class Type>
inline static Type& store(Type* p);
//- Register object pointer with its registry
//- and transfer ownership to the registry.
// Clears the autoPtr parameter.
// \return reference to the object.
//- Transfer pointer ownership to its registry.
// Resets (clears) the parameter.
// \return reference to the stored object
template<class Type>
inline static Type& store(autoPtr<Type>& aptr);
inline static Type& store(autoPtr<Type>& ptr);
//- Register object pointer with its registry
//- and transfer ownership to the registry.
// Clears the autoPtr parameter.
// \return reference to the object.
//- Transfer pointer ownership to its registry.
// Resets (clears) the parameter.
// \return reference to the stored object
template<class Type>
inline static Type& store(autoPtr<Type>&& ptr);
//- Transfer pointer ownership to its registry.
// Changes parameter from PTR to CREF (do not rely on this).
// \return reference to the stored object
template<class Type>
inline static Type& store(refPtr<Type>& ptr);
//- Transfer pointer ownership to its registry.
// Changes parameter from PTR to CREF (do not rely on this).
// \return reference to the stored object
template<class Type>
inline static Type& store(autoPtr<Type>&& aptr);
inline static Type& store(refPtr<Type>&& ptr);
//- Register temporary pointer with its registry
//- and transfer ownership of pointer to the registry.
// After the call, tmp parameter changes from PTR to CREF.
//
// \return reference to the object.
//- Transfer pointer ownership to its registry.
// Changes parameter from PTR to CREF (do not rely on this).
// \return reference to the stored object
template<class Type>
inline static Type& store(tmp<Type>& tptr);
inline static Type& store(tmp<Type>& ptr);
//- Register temporary pointer with its registry
//- and transfer ownership of pointer to the registry.
// After the call, the tmp parameter content is \em unspecified.
//
// \return reference to the object.
//- Transfer pointer ownership to its registry.
// Changes parameter from PTR to CREF (do not rely on this).
// \return reference to the stored object
template<class Type>
inline static Type& store(tmp<Type>&& tptr);
inline static Type& store(tmp<Type>&& ptr);
//- Release ownership of this object from its registry
// \param unregister optionally set as non-registered
......
......@@ -75,47 +75,88 @@ inline Type& Foam::regIOobject::store(Type* p)
template<class Type>
inline Type& Foam::regIOobject::store(autoPtr<Type>& aptr)
inline Type& Foam::regIOobject::store(autoPtr<Type>& ptr)
{
// Pass management to objectRegistry
return store(aptr.release());
return store(ptr.release());
}
template<class Type>
inline Type& Foam::regIOobject::store(autoPtr<Type>&& aptr)
inline Type& Foam::regIOobject::store(autoPtr<Type>&& ptr)
{
// Pass management to objectRegistry
return store(aptr.release());
return store(ptr.release());
}
template<class Type>
inline Type& Foam::regIOobject::store(tmp<Type>& tptr)
inline Type& Foam::regIOobject::store(refPtr<Type>& ptr)
{
Type* p = nullptr;
if (tptr.isTmp())
if (ptr.is_pointer())
{
// Pass management to objectRegistry
p = tptr.ptr();
// Acquire ownership, pass management to objectRegistry
p = ptr.ptr();
store(p);
// Change parameter to access the stored reference
ptr.cref(*p);
}
else
{
// Taking ownership of reference does not make much sense.
// - Storing the object won't actually do so, it will be removed
// when the original object goes out of scope.
// - Storing a clone may not be what we want.
p = ptr.get();
WarningInFunction
<< "Refuse to store reference: " << p->name()
<< ". Likely indicates a coding error\n";
}
return *p;
}
template<class Type>
inline Type& Foam::regIOobject::store(refPtr<Type>&& ptr)
{
// Forward as named reference, which also does a move
return store(ptr);
}
template<class Type>
inline Type& Foam::regIOobject::store(tmp<Type>& ptr)
{
Type* p = nullptr;
if (ptr.is_pointer())
{
// Acquire ownership, pass management to objectRegistry
p = ptr.ptr();
store(p);
// Adjust tmp<> access to use the stored reference
tptr.cref(*p);
// Change parameter to access the stored reference
ptr.cref(*p);
}
else
{
// Taking ownership of a const-ref does not make much sense.
// Taking ownership of reference does not make much sense.
// - Storing the object won't actually do so, it will be removed
// when the original object goes out of scope.
// - Storing a clone may not be what we want.
p = tptr.get();
p = ptr.get();
WarningInFunction
<< "Refuse to store tmp to const-ref: " << p->name()
<< "Refuse to store reference: " << p->name()
<< ". Likely indicates a coding error\n";
}
......@@ -124,10 +165,10 @@ inline Type& Foam::regIOobject::store(tmp<Type>& tptr)
template<class Type>
inline Type& Foam::regIOobject::store(tmp<Type>&& tptr)
inline Type& Foam::regIOobject::store(tmp<Type>&& ptr)
{
// Treat like a normal reference
return store(tptr);
// Forward as named reference, which also does a move
return store(ptr);
}
......
Markdown is supported
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