zhyang-dev/openfoam
1
0
Fork 0
mirror of https://develop.openfoam.com/Development/openfoam.git synced 2025-11-28 03:28:01 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

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

Browse Source
This commit is contained in:
Mark Olesen
2020-07-30 09:45:55 +02:00
parent 487002d2e2
commit e56e195ab5
2 changed files with 92 additions and 45 deletions
Download Patch File Download Diff File Expand all files Collapse all files

64
src/OpenFOAM/db/regIOobject/regIOobject.H
View File

@ -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>&& aptr);
inline static Type& store(autoPtr<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(refPtr<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(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(tmp<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(tmp<Type>&& ptr);
//- Release ownership of this object from its registry
// \param unregister optionally set as non-registered

73
src/OpenFOAM/db/regIOobject/regIOobjectI.H
View File

@ -75,47 +75,47 @@ 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);
// 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 +124,51 @@ inline Type& Foam::regIOobject::store(tmp<Type>& tptr)
template<class Type>
inline Type& Foam::regIOobject::store(tmp<Type>&& tptr)
inline Type& Foam::regIOobject::store(refPtr<Type>&& ptr)
{
// Treat like a normal reference
return store(tptr);
// 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);
// 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(tmp<Type>&& ptr)
{
// Forward as named reference, which also does a move
return store(ptr);
}