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: cleanup tmp class (issue #639)

Browse Source 
Improve alignment of its behaviour with std::shared_ptr

  - element_type typedef
  - swap, reset methods

* additional reference access methods:

cref()
    returns a const reference, synonymous with operator().
    This provides a more verbose alternative to using the '()' operator
    when that is desired.

        Mnemonic: a const form of 'ref()'

constCast()
    returns a non-const reference, regardless if the underlying object
    itself is a managed pointer or a const object.
    This is similar to ref(), but more permissive.

        Mnemonic: const_cast<>

    Using the constCast() method greatly reduces the amount of typing
    and reading. And since the data type is already defined via the tmp
    template parameter, the type deduction is automatically known.

    Previously,

        const tmp<volScalarField>& tfld;

        const_cast<volScalarField&>(tfld()).rename("name");
        volScalarField& fld = const_cast<volScalarField&>(tfld());

    Now,

        tfld.constCast().rename("name");
        auto& fld = tfld.constCast();

--

BUG: attempts to move tmp value that may still be shared.

- old code simply checked isTmp() to decide if the contents could be
  transfered. However, this means that the content of a shared tmp
  would be removed, leaving other instances without content.

* movable() method checks that for a non-null temporary that is
  unique (not shared).
This commit is contained in:
Mark Olesen
2018-02-26 12:05:00 +01:00
parent 660f3e5492
commit 52b36f84b5
41 changed files with 1034 additions and 815 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
applications/test/tmp/Make/files Normal file
View File

@ -0,0 +1,3 @@
Test-tmp.C
EXE = $(FOAM_USER_APPBIN)/Test-tmp

0
applications/test/tmpField/Make/options → applications/test/tmp/Make/options
View File

47
applications/test/tmpField/Test-tmpField.C → applications/test/tmp/Test-tmp.C
View File

@ -3,7 +3,7 @@
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox \\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | \\ / O peration |
\\ / A nd | Copyright (C) 2011 OpenFOAM Foundation \\ / A nd | Copyright (C) 2011 OpenFOAM Foundation
\\/ M anipulation | \\/ M anipulation | Copyright (C) 2018 OpenCFD Ltd.
------------------------------------------------------------------------------- -------------------------------------------------------------------------------
License License
This file is part of OpenFOAM. This file is part of OpenFOAM.
@ -22,10 +22,10 @@ License
along with OpenFOAM. If not, see <http://www.gnu.org/licenses/>. along with OpenFOAM. If not, see <http://www.gnu.org/licenses/>.
Application Application
tmpFieldTest Test-tmp
Description Description
Tests for possible memory leaks in the tmp<Field> algebra. Tests for possible memory leaks in the tmp (and tmp<Field> algebra).
\*---------------------------------------------------------------------------*/ \*---------------------------------------------------------------------------*/
@ -33,19 +33,50 @@ Description
using namespace Foam; using namespace Foam;
struct myScalarField : public scalarField
{
using scalarField::scalarField;
};
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
// Main program: // Main program:
int main() int main()
{ {
scalarField f1(1000000, 1.0), f2(1000000, 2.0), f3(1000000, 3.0);
for (;;)
{ {
f1 = f2 + f3 + f2 + f3; scalarField f1(1000000, 1.0), f2(1000000, 2.0), f3(1000000, 3.0);
for (int iter=0; iter < 50; ++iter)
{
f1 = f2 + f3 + f2 + f3;
}
Info<<"f1 = " << f1 << nl;
} }
Info<< "end" << endl; {
tmp<scalarField> tfld1 = tmp<scalarField>::New(20, Zero);
Info<< "tmp refCount = " << tfld1->count() << nl;
if (tfld1.valid())
{
Info<<"tmp: " << tfld1() << nl;
}
}
{
tmp<scalarField> tfld2 =
tmp<scalarField>::NewFrom<myScalarField>(20, Zero);
Info<< "tmp refCount = " << tfld2->count() << nl;
if (tfld2.valid())
{
Info<<"tmp: " << tfld2() << nl;
}
}
Info<< "\nEnd" << endl;
} }

3
applications/test/tmpField/Make/files
View File

@ -1,3 +0,0 @@
Test-tmpField.C
EXE = $(FOAM_USER_APPBIN)/Test-tmpField

18
src/OpenFOAM/fields/DimensionedFields/DimensionedField/DimensionedField.C
View File

@ -217,12 +217,8 @@ DimensionedField<Type, GeoMesh>::DimensionedField
const tmp<DimensionedField<Type, GeoMesh>>& tdf const tmp<DimensionedField<Type, GeoMesh>>& tdf
) )
: :
regIOobject(tdf(), tdf.isTmp()), regIOobject(tdf.constCast(), tdf.movable()),
Field<Type> Field<Type>(tdf.constCast(), tdf.movable()),
(
const_cast<DimensionedField<Type, GeoMesh>&>(tdf()),
tdf.isTmp()
),
mesh_(tdf().mesh_), mesh_(tdf().mesh_),
dimensions_(tdf().dimensions_), dimensions_(tdf().dimensions_),
oriented_(tdf().oriented_) oriented_(tdf().oriented_)
@ -318,11 +314,7 @@ DimensionedField<Type, GeoMesh>::DimensionedField
) )
: :
regIOobject(newName, tdf(), true), regIOobject(newName, tdf(), true),
Field<Type> Field<Type>(tdf.constCast(), tdf.movable()),
(
const_cast<DimensionedField<Type, GeoMesh>&>(tdf()),
tdf.isTmp()
),
mesh_(tdf().mesh_), mesh_(tdf().mesh_),
dimensions_(tdf().dimensions_), dimensions_(tdf().dimensions_),
oriented_(tdf().oriented_) oriented_(tdf().oriented_)
@ -511,7 +503,7 @@ void DimensionedField<Type, GeoMesh>::operator=
const tmp<DimensionedField<Type, GeoMesh>>& tdf const tmp<DimensionedField<Type, GeoMesh>>& tdf
) )
{ {
const DimensionedField<Type, GeoMesh>& df = tdf(); auto& df = tdf.constCast();
// Check for assignment to self // Check for assignment to self
if (this == &df) if (this == &df)
@ -525,7 +517,7 @@ void DimensionedField<Type, GeoMesh>::operator=
dimensions_ = df.dimensions(); dimensions_ = df.dimensions();
oriented_ = df.oriented(); oriented_ = df.oriented();
this->transfer(const_cast<DimensionedField<Type, GeoMesh>&>(df)); this->transfer(df);
tdf.clear(); tdf.clear();
} }

186
src/OpenFOAM/fields/DimensionedFields/DimensionedField/DimensionedFieldReuseFunctions.H
View File

@ -3,7 +3,7 @@
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox \\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | \\ / O peration |
\\ / A nd | Copyright (C) 2011-2016 OpenFOAM Foundation \\ / A nd | Copyright (C) 2011-2016 OpenFOAM Foundation
\\/ M anipulation | \\/ M anipulation | Copyright (C) 2018 OpenCFD Ltd.
------------------------------------------------------------------------------- -------------------------------------------------------------------------------
License License
This file is part of OpenFOAM. This file is part of OpenFOAM.
@ -41,32 +41,31 @@ tmp<DimensionedField<TypeR, GeoMesh>> New
const dimensionSet& dimensions const dimensionSet& dimensions
) )
{ {
DimensionedField<TypeR, GeoMesh>& df1 =
const_cast<DimensionedField<TypeR, GeoMesh>&>(tdf1());
if (tdf1.isTmp()) if (tdf1.isTmp())
{ {
auto& df1 = tdf1.constCast();
df1.rename(name); df1.rename(name);
df1.dimensions().reset(dimensions); df1.dimensions().reset(dimensions);
return tdf1; return tdf1;
} }
else
{ const auto& df1 = tdf1();
return tmp<DimensionedField<TypeR, GeoMesh>>
return tmp<DimensionedField<TypeR, GeoMesh>>
(
new DimensionedField<TypeR, GeoMesh>
( (
new DimensionedField<TypeR, GeoMesh> IOobject
( (
IOobject name,
( df1.instance(),
name, df1.db()
df1.instance(), ),
df1.db() df1.mesh(),
), dimensions
df1.mesh(), )
dimensions );
)
);
}
} }
@ -82,7 +81,7 @@ public:
const dimensionSet& dimensions const dimensionSet& dimensions
) )
{ {
const DimensionedField<Type1, GeoMesh>& df1 = tdf1(); const auto& df1 = tdf1();
return tmp<DimensionedField<TypeR, GeoMesh>> return tmp<DimensionedField<TypeR, GeoMesh>>
( (
@ -114,32 +113,31 @@ public:
const dimensionSet& dimensions const dimensionSet& dimensions
) )
{ {
DimensionedField<TypeR, GeoMesh>& df1 =
const_cast<DimensionedField<TypeR, GeoMesh>&>(tdf1());
if (tdf1.isTmp()) if (tdf1.isTmp())
{ {
auto& df1 = tdf1.constCast();
df1.rename(name); df1.rename(name);
df1.dimensions().reset(dimensions); df1.dimensions().reset(dimensions);
return tdf1; return tdf1;
} }
else
{ const auto& df1 = tdf1();
return tmp<DimensionedField<TypeR, GeoMesh>>
return tmp<DimensionedField<TypeR, GeoMesh>>
(
new DimensionedField<TypeR, GeoMesh>
( (
new DimensionedField<TypeR, GeoMesh> IOobject
( (
IOobject name,
( df1.instance(),
name, df1.db()
df1.instance(), ),
df1.db() df1.mesh(),
), dimensions
df1.mesh(), )
dimensions );
)
);
}
} }
}; };
@ -157,7 +155,7 @@ public:
const dimensionSet& dimensions const dimensionSet& dimensions
) )
{ {
const DimensionedField<Type1, GeoMesh>& df1 = tdf1(); const auto& df1 = tdf1();
return tmp<DimensionedField<TypeR, GeoMesh>> return tmp<DimensionedField<TypeR, GeoMesh>>
( (
@ -190,33 +188,31 @@ public:
const dimensionSet& dimensions const dimensionSet& dimensions
) )
{ {
const DimensionedField<Type1, GeoMesh>& df1 = tdf1();
DimensionedField<TypeR, GeoMesh>& df2 =
const_cast<DimensionedField<TypeR, GeoMesh>&>(tdf2());
if (tdf2.isTmp()) if (tdf2.isTmp())
{ {
auto& df2 = tdf2.constCast();
df2.rename(name); df2.rename(name);
df2.dimensions().reset(dimensions); df2.dimensions().reset(dimensions);
return tdf2; return tdf2;
} }
else
{ const auto& df1 = tdf1();
return tmp<DimensionedField<TypeR, GeoMesh>>
return tmp<DimensionedField<TypeR, GeoMesh>>
(
new DimensionedField<TypeR, GeoMesh>
( (
new DimensionedField<TypeR, GeoMesh> IOobject
( (
IOobject name,
( df1.instance(),
name, df1.db()
df1.instance(), ),
df1.db() df1.mesh(),
), dimensions
df1.mesh(), )
dimensions );
)
);
}
} }
}; };
@ -234,32 +230,31 @@ public:
const dimensionSet& dimensions const dimensionSet& dimensions
) )
{ {
DimensionedField<TypeR, GeoMesh>& df1 =
const_cast<DimensionedField<TypeR, GeoMesh>&>(tdf1());
if (tdf1.isTmp()) if (tdf1.isTmp())
{ {
auto& df1 = tdf1.constCast();
df1.rename(name); df1.rename(name);
df1.dimensions().reset(dimensions); df1.dimensions().reset(dimensions);
return tdf1; return tdf1;
} }
else
{ const auto& df1 = tdf1();
return tmp<DimensionedField<TypeR, GeoMesh>>
return tmp<DimensionedField<TypeR, GeoMesh>>
(
new DimensionedField<TypeR, GeoMesh>
( (
new DimensionedField<TypeR, GeoMesh> IOobject
( (
IOobject name,
( df1.instance(),
name, df1.db()
df1.instance(), ),
df1.db() df1.mesh(),
), dimensions
df1.mesh(), )
dimensions );
)
);
}
} }
}; };
@ -277,40 +272,39 @@ public:
const dimensionSet& dimensions const dimensionSet& dimensions
) )
{ {
DimensionedField<TypeR, GeoMesh>& df1 =
const_cast<DimensionedField<TypeR, GeoMesh>&>(tdf1());
DimensionedField<TypeR, GeoMesh>& df2 =
const_cast<DimensionedField<TypeR, GeoMesh>&>(tdf2());
if (tdf1.isTmp()) if (tdf1.isTmp())
{ {
auto& df1 = tdf1.constCast();
df1.rename(name); df1.rename(name);
df1.dimensions().reset(dimensions); df1.dimensions().reset(dimensions);
return tdf1; return tdf1;
} }
else if (tdf2.isTmp()) else if (tdf2.isTmp())
{ {
auto& df2 = tdf2.constCast();
df2.rename(name); df2.rename(name);
df2.dimensions().reset(dimensions); df2.dimensions().reset(dimensions);
return tdf2; return tdf2;
} }
else
{ const auto& df1 = tdf1();
return tmp<DimensionedField<TypeR, GeoMesh>>
return tmp<DimensionedField<TypeR, GeoMesh>>
(
new DimensionedField<TypeR, GeoMesh>
( (
new DimensionedField<TypeR, GeoMesh> IOobject
( (
IOobject name,
( df1.instance(),
name, df1.db()
df1.instance(), ),
df1.db() df1.mesh(),
), dimensions
df1.mesh(), )
dimensions );
)
);
}
} }
}; };

6
src/OpenFOAM/fields/FieldFields/FieldField/FieldField.C
View File

@ -160,11 +160,7 @@ FieldField<Field, Type>::FieldField(const PtrList<Field<Type>>& tl)
template<template<class> class Field, class Type> template<template<class> class Field, class Type>
FieldField<Field, Type>::FieldField(const tmp<FieldField<Field, Type>>& tf) FieldField<Field, Type>::FieldField(const tmp<FieldField<Field, Type>>& tf)
: :
PtrList<Field<Type>> PtrList<Field<Type>>(tf.constCast(), tf.movable())
(
const_cast<FieldField<Field, Type>&>(tf()),
tf.isTmp()
)
{ {
tf.clear(); tf.clear();
} }

72
src/OpenFOAM/fields/FieldFields/FieldField/FieldFieldReuseFunctions.H
View File

@ -3,7 +3,7 @@
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox \\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | \\ / O peration |
\\ / A nd | Copyright (C) 2011-2016 OpenFOAM Foundation \\ / A nd | Copyright (C) 2011-2016 OpenFOAM Foundation
\\/ M anipulation | \\/ M anipulation | Copyright (C) 2018 OpenCFD Ltd.
------------------------------------------------------------------------------- -------------------------------------------------------------------------------
License License
This file is part of OpenFOAM. This file is part of OpenFOAM.
@ -44,20 +44,18 @@ tmp<FieldField<Field, TypeR>> New
{ {
return tf1; return tf1;
} }
else
tmp<FieldField<Field, TypeR>> rtf
(
FieldField<Field, TypeR>::NewCalculatedType(tf1())
);
if (initRet)
{ {
tmp<FieldField<Field, TypeR>> rtf rtf.ref() = tf1();
(
FieldField<Field, TypeR>::NewCalculatedType(tf1())
);
if (initRet)
{
rtf.ref() = tf1();
}
return rtf;
} }
return rtf;
} }
@ -93,13 +91,11 @@ public:
{ {
return tf1; return tf1;
} }
else
{ return tmp<FieldField<Field, TypeR>>
return tmp<FieldField<Field, TypeR>> (
( FieldField<Field, TypeR>::NewCalculatedType(tf1())
FieldField<Field, TypeR>::NewCalculatedType(tf1()) );
);
}
} }
}; };
@ -145,13 +141,11 @@ public:
{ {
return tf2; return tf2;
} }
else
{ return tmp<FieldField<Field, TypeR>>
return tmp<FieldField<Field, TypeR>> (
( FieldField<Field, TypeR>::NewCalculatedType(tf1())
FieldField<Field, TypeR>::NewCalculatedType(tf1()) );
);
}
} }
}; };
@ -171,13 +165,11 @@ public:
{ {
return tf1; return tf1;
} }
else
{ return tmp<FieldField<Field, TypeR>>
return tmp<FieldField<Field, TypeR>> (
( FieldField<Field, TypeR>::NewCalculatedType(tf1())
FieldField<Field, TypeR>::NewCalculatedType(tf1()) );
);
}
} }
}; };
@ -201,13 +193,11 @@ public:
{ {
return tf2; return tf2;
} }
else
{ return tmp<FieldField<Field, TypeR>>
return tmp<FieldField<Field, TypeR>> (
( FieldField<Field, TypeR>::NewCalculatedType(tf1())
FieldField<Field, TypeR>::NewCalculatedType(tf1()) );
);
}
} }
}; };

2
src/OpenFOAM/fields/Fields/Field/Field.C
View File

@ -256,7 +256,7 @@ Foam::Field<Type>::Field(const UIndirectList<Type>& list)
template<class Type> template<class Type>
Foam::Field<Type>::Field(const tmp<Field<Type>>& tf) Foam::Field<Type>::Field(const tmp<Field<Type>>& tf)
: :
List<Type>(const_cast<Field<Type>&>(tf()), tf.isTmp()) List<Type>(tf.constCast(), tf.movable())
{ {
tf.clear(); tf.clear();
} }

40
src/OpenFOAM/fields/Fields/Field/FieldReuseFunctions.H
View File

@ -44,17 +44,15 @@ tmp<Field<TypeR>> New
{ {
return tf1; return tf1;
} }
else
tmp<Field<TypeR>> rtf(new Field<TypeR>(tf1().size()));
if (initRet)
{ {
tmp<Field<TypeR>> rtf(new Field<TypeR>(tf1().size())); rtf.ref() = tf1();
if (initRet)
{
rtf.ref() = tf1();
}
return rtf;
} }
return rtf;
} }
@ -81,10 +79,8 @@ public:
{ {
return tf1; return tf1;
} }
else
{ return tmp<Field<TypeR>>(new Field<TypeR>(tf1().size()));
return tmp<Field<TypeR>>(new Field<TypeR>(tf1().size()));
}
} }
}; };
@ -120,10 +116,8 @@ public:
{ {
return tf2; return tf2;
} }
else
{ return tmp<Field<TypeR>>(new Field<TypeR>(tf1().size()));
return tmp<Field<TypeR>>(new Field<TypeR>(tf1().size()));
}
} }
}; };
@ -143,10 +137,8 @@ public:
{ {
return tf1; return tf1;
} }
else
{ return tmp<Field<TypeR>>(new Field<TypeR>(tf1().size()));
return tmp<Field<TypeR>>(new Field<TypeR>(tf1().size()));
}
} }
}; };
@ -170,10 +162,8 @@ public:
{ {
return tf2; return tf2;
} }
else
{ return tmp<Field<TypeR>>(new Field<TypeR>(tf1().size()));
return tmp<Field<TypeR>>(new Field<TypeR>(tf1().size()));
}
} }
}; };

29
src/OpenFOAM/fields/GeometricFields/GeometricField/GeometricField.C
View File

@ -455,11 +455,7 @@ Foam::GeometricField<Type, PatchField, GeoMesh>::GeometricField
const tmp<GeometricField<Type, PatchField, GeoMesh>>& tgf const tmp<GeometricField<Type, PatchField, GeoMesh>>& tgf
) )
: :
Internal Internal(tgf.constCast(), tgf.movable()),
(
const_cast<GeometricField<Type, PatchField, GeoMesh>&>(tgf()),
tgf.isTmp()
),
timeIndex_(tgf().timeIndex()), timeIndex_(tgf().timeIndex()),
field0Ptr_(nullptr), field0Ptr_(nullptr),
fieldPrevIterPtr_(nullptr), fieldPrevIterPtr_(nullptr),
@ -517,12 +513,7 @@ Foam::GeometricField<Type, PatchField, GeoMesh>::GeometricField
const tmp<GeometricField<Type, PatchField, GeoMesh>>& tgf const tmp<GeometricField<Type, PatchField, GeoMesh>>& tgf
) )
: :
Internal Internal(io, tgf.constCast(), tgf.movable()),
(
io,
const_cast<GeometricField<Type, PatchField, GeoMesh>&>(tgf()),
tgf.isTmp()
),
timeIndex_(tgf().timeIndex()), timeIndex_(tgf().timeIndex()),
field0Ptr_(nullptr), field0Ptr_(nullptr),
fieldPrevIterPtr_(nullptr), fieldPrevIterPtr_(nullptr),
@ -581,12 +572,7 @@ Foam::GeometricField<Type, PatchField, GeoMesh>::GeometricField
const tmp<GeometricField<Type, PatchField, GeoMesh>>& tgf const tmp<GeometricField<Type, PatchField, GeoMesh>>& tgf
) )
: :
Internal Internal(newName, tgf.constCast(), tgf.movable()),
(
newName,
const_cast<GeometricField<Type, PatchField, GeoMesh>&>(tgf()),
tgf.isTmp()
),
timeIndex_(tgf().timeIndex()), timeIndex_(tgf().timeIndex()),
field0Ptr_(nullptr), field0Ptr_(nullptr),
fieldPrevIterPtr_(nullptr), fieldPrevIterPtr_(nullptr),
@ -690,12 +676,7 @@ Foam::GeometricField<Type, PatchField, GeoMesh>::GeometricField
const wordList& actualPatchTypes const wordList& actualPatchTypes
) )
: :
Internal Internal(io, tgf.constCast(), tgf.movable()),
(
io,
const_cast<GeometricField<Type, PatchField, GeoMesh>&>(tgf()),
tgf.isTmp()
),
timeIndex_(tgf().timeIndex()), timeIndex_(tgf().timeIndex()),
field0Ptr_(nullptr), field0Ptr_(nullptr),
fieldPrevIterPtr_(nullptr), fieldPrevIterPtr_(nullptr),
@ -1221,7 +1202,7 @@ void Foam::GeometricField<Type, PatchField, GeoMesh>::operator=
this->dimensions() = gf.dimensions(); this->dimensions() = gf.dimensions();
this->oriented() = gf.oriented(); this->oriented() = gf.oriented();
if (tgf.isTmp()) if (tgf.movable())
{ {
// Transfer the storage from the tmp // Transfer the storage from the tmp
primitiveFieldRef().transfer primitiveFieldRef().transfer

26
src/OpenFOAM/fields/GeometricFields/GeometricField/GeometricField.H
View File

@ -125,16 +125,16 @@ public:
// Constructors // Constructors
//- Construct from a BoundaryMesh //- Construct from a BoundaryMesh
Boundary(const BoundaryMesh&); Boundary(const BoundaryMesh& bmesh);
//- Construct from a BoundaryMesh, //- Construct from a BoundaryMesh,
// reference to the internal field // reference to the internal field
// and a patch type // and a patch type
Boundary Boundary
( (
const BoundaryMesh&, const BoundaryMesh& bmesh,
const Internal&, const Internal& field,
const word& const word& patchFieldType
); );
//- Construct from a BoundaryMesh, //- Construct from a BoundaryMesh,
@ -143,8 +143,8 @@ public:
// types (to override constraint patches) // types (to override constraint patches)
Boundary Boundary
( (
const BoundaryMesh&, const BoundaryMesh& bmesh,
const Internal&, const Internal& field,
const wordList& wantedPatchTypes, const wordList& wantedPatchTypes,
const wordList& actualPatchTypes = wordList() const wordList& actualPatchTypes = wordList()
); );
@ -154,16 +154,16 @@ public:
// and a PtrList<PatchField<Type>> // and a PtrList<PatchField<Type>>
Boundary Boundary
( (
const BoundaryMesh&, const BoundaryMesh& bmesh,
const Internal&, const Internal& field,
const PtrList<PatchField<Type>>& const PtrList<PatchField<Type>>&
); );
//- Construct as copy setting the reference to the internal field //- Construct as copy setting the reference to the internal field
Boundary Boundary
( (
const Internal&, const Internal& field,
const Boundary& const Boundary& btf
); );
//- Construct as copy //- Construct as copy
@ -173,14 +173,14 @@ public:
// BoundaryField for which such operations are unavailable. // BoundaryField for which such operations are unavailable.
Boundary Boundary
( (
const Boundary& const Boundary& btf
); );
//- Construct from dictionary //- Construct from dictionary
Boundary Boundary
( (
const BoundaryMesh&, const BoundaryMesh& bmesh,
const Internal&, const Internal& field,
const dictionary& const dictionary&
); );

207
src/OpenFOAM/fields/GeometricFields/GeometricField/GeometricFieldReuseFunctions.H
View File

@ -3,7 +3,7 @@
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox \\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | \\ / O peration |
\\ / A nd | Copyright (C) 2011-2016 OpenFOAM Foundation \\ / A nd | Copyright (C) 2011-2016 OpenFOAM Foundation
\\/ M anipulation | \\/ M anipulation | Copyright (C) 2018 OpenCFD Ltd.
------------------------------------------------------------------------------- -------------------------------------------------------------------------------
License License
This file is part of OpenFOAM. This file is part of OpenFOAM.
@ -45,9 +45,8 @@ bool reusable(const tmp<GeometricField<Type, PatchField, GeoMesh>>& tgf)
{ {
if (GeometricField<Type, PatchField, GeoMesh>::debug) if (GeometricField<Type, PatchField, GeoMesh>::debug)
{ {
const GeometricField<Type, PatchField, GeoMesh>& gf = tgf(); const auto& gf = tgf();
const typename GeometricField<Type, PatchField, GeoMesh>:: const auto& gbf = gf.boundaryField();
Boundary& gbf = gf.boundaryField();
forAll(gbf, patchi) forAll(gbf, patchi)
{ {
@ -68,10 +67,8 @@ bool reusable(const tmp<GeometricField<Type, PatchField, GeoMesh>>& tgf)
return true; return true;
} }
else
{ return false;
return false;
}
} }
@ -84,39 +81,38 @@ tmp<GeometricField<TypeR, PatchField, GeoMesh>> New
const bool initRet = false const bool initRet = false
) )
{ {
GeometricField<TypeR, PatchField, GeoMesh>& gf1 =
const_cast<GeometricField<TypeR, PatchField, GeoMesh>&>(tgf1());
if (reusable(tgf1)) if (reusable(tgf1))
{ {
auto& gf1 = tgf1.constCast();
gf1.rename(name); gf1.rename(name);
gf1.dimensions().reset(dimensions); gf1.dimensions().reset(dimensions);
return tgf1; return tgf1;
} }
else
{ const auto& gf1 = tgf1();
tmp<GeometricField<TypeR, PatchField, GeoMesh>> rtgf
tmp<GeometricField<TypeR, PatchField, GeoMesh>> rtgf
(
new GeometricField<TypeR, PatchField, GeoMesh>
( (
new GeometricField<TypeR, PatchField, GeoMesh> IOobject
( (
IOobject name,
( gf1.instance(),
name, gf1.db()
gf1.instance(), ),
gf1.db() gf1.mesh(),
), dimensions
gf1.mesh(), )
dimensions );
)
);
if (initRet) if (initRet)
{ {
rtgf.ref() == tgf1(); rtgf.ref() == gf1;
}
return rtgf;
} }
return rtgf;
} }
@ -138,7 +134,7 @@ public:
const dimensionSet& dimensions const dimensionSet& dimensions
) )
{ {
const GeometricField<Type1, PatchField, GeoMesh>& gf1 = tgf1(); const auto& gf1 = tgf1();
return tmp<GeometricField<TypeR, PatchField, GeoMesh>> return tmp<GeometricField<TypeR, PatchField, GeoMesh>>
( (
@ -170,32 +166,31 @@ public:
const dimensionSet& dimensions const dimensionSet& dimensions
) )
{ {
GeometricField<TypeR, PatchField, GeoMesh>& gf1 =
const_cast<GeometricField<TypeR, PatchField, GeoMesh>&>(tgf1());
if (reusable(tgf1)) if (reusable(tgf1))
{ {
auto& gf1 = tgf1.constCast();
gf1.rename(name); gf1.rename(name);
gf1.dimensions().reset(dimensions); gf1.dimensions().reset(dimensions);
return tgf1; return tgf1;
} }
else
{ const auto& gf1 = tgf1();
return tmp<GeometricField<TypeR, PatchField, GeoMesh>>
return tmp<GeometricField<TypeR, PatchField, GeoMesh>>
(
new GeometricField<TypeR, PatchField, GeoMesh>
( (
new GeometricField<TypeR, PatchField, GeoMesh> IOobject
( (
IOobject name,
( gf1.instance(),
name, gf1.db()
gf1.instance(), ),
gf1.db() gf1.mesh(),
), dimensions
gf1.mesh(), )
dimensions );
)
);
}
} }
}; };
@ -221,7 +216,7 @@ public:
const dimensionSet& dimensions const dimensionSet& dimensions
) )
{ {
const GeometricField<Type1, PatchField, GeoMesh>& gf1 = tgf1(); const auto& gf1 = tgf1();
return tmp<GeometricField<TypeR, PatchField, GeoMesh>> return tmp<GeometricField<TypeR, PatchField, GeoMesh>>
( (
@ -262,33 +257,31 @@ public:
const dimensionSet& dimensions const dimensionSet& dimensions
) )
{ {
const GeometricField<Type1, PatchField, GeoMesh>& gf1 = tgf1();
GeometricField<TypeR, PatchField, GeoMesh>& gf2 =
const_cast<GeometricField<TypeR, PatchField, GeoMesh>&>(tgf2());
if (reusable(tgf2)) if (reusable(tgf2))
{ {
auto& gf2 = tgf2.constCast();
gf2.rename(name); gf2.rename(name);
gf2.dimensions().reset(dimensions); gf2.dimensions().reset(dimensions);
return tgf2; return tgf2;
} }
else
{ const auto& gf1 = tgf1();
return tmp<GeometricField<TypeR, PatchField, GeoMesh>>
return tmp<GeometricField<TypeR, PatchField, GeoMesh>>
(
new GeometricField<TypeR, PatchField, GeoMesh>
( (
new GeometricField<TypeR, PatchField, GeoMesh> IOobject
( (
IOobject name,
( gf1.instance(),
name, gf1.db()
gf1.instance(), ),
gf1.db() gf1.mesh(),
), dimensions
gf1.mesh(), )
dimensions );
)
);
}
} }
}; };
@ -312,32 +305,31 @@ public:
const dimensionSet& dimensions const dimensionSet& dimensions
) )
{ {
GeometricField<TypeR, PatchField, GeoMesh>& gf1 =
const_cast<GeometricField<TypeR, PatchField, GeoMesh>&>(tgf1());
if (reusable(tgf1)) if (reusable(tgf1))
{ {
auto& gf1 = tgf1.constCast();
gf1.rename(name); gf1.rename(name);
gf1.dimensions().reset(dimensions); gf1.dimensions().reset(dimensions);
return tgf1; return tgf1;
} }
else
{ const auto& gf1 = tgf1();
return tmp<GeometricField<TypeR, PatchField, GeoMesh>>
return tmp<GeometricField<TypeR, PatchField, GeoMesh>>
(
new GeometricField<TypeR, PatchField, GeoMesh>
( (
new GeometricField<TypeR, PatchField, GeoMesh> IOobject
( (
IOobject name,
( gf1.instance(),
name, gf1.db()
gf1.instance(), ),
gf1.db() gf1.mesh(),
), dimensions
gf1.mesh(), )
dimensions );
)
);
}
} }
}; };
@ -355,40 +347,39 @@ public:
const dimensionSet& dimensions const dimensionSet& dimensions
) )
{ {
GeometricField<TypeR, PatchField, GeoMesh>& gf1 =
const_cast<GeometricField<TypeR, PatchField, GeoMesh>&>(tgf1());
GeometricField<TypeR, PatchField, GeoMesh>& gf2 =
const_cast<GeometricField<TypeR, PatchField, GeoMesh>&>(tgf2());
if (reusable(tgf1)) if (reusable(tgf1))
{ {
auto& gf1 = tgf1.constCast();
gf1.rename(name); gf1.rename(name);
gf1.dimensions().reset(dimensions); gf1.dimensions().reset(dimensions);
return tgf1; return tgf1;
} }
else if (reusable(tgf2)) else if (reusable(tgf2))
{ {
auto& gf2 = tgf2.constCast();
gf2.rename(name); gf2.rename(name);
gf2.dimensions().reset(dimensions); gf2.dimensions().reset(dimensions);
return tgf2; return tgf2;
} }
else
{ const auto& gf1 = tgf1();
return tmp<GeometricField<TypeR, PatchField, GeoMesh>>
return tmp<GeometricField<TypeR, PatchField, GeoMesh>>
(
new GeometricField<TypeR, PatchField, GeoMesh>
( (
new GeometricField<TypeR, PatchField, GeoMesh> IOobject
( (
IOobject name,
( gf1.instance(),
name, gf1.db()
gf1.instance(), ),
gf1.db() gf1.mesh(),
), dimensions
gf1.mesh(), )
dimensions );
)
);
}
} }
}; };

14
src/OpenFOAM/matrices/lduMatrix/lduMatrix/lduMatrixTemplates.C
View File

@ -98,15 +98,13 @@ Foam::lduMatrix::faceH(const Field<Type>& psi) const
return tfaceHpsi; return tfaceHpsi;
} }
else
{
FatalErrorInFunction
<< "Cannot calculate faceH"
" the matrix does not have any off-diagonal coefficients."
<< exit(FatalError);
return tmp<Field<Type>>(nullptr); FatalErrorInFunction
} << "Cannot calculate faceH"
" the matrix does not have any off-diagonal coefficients."
<< exit(FatalError);
return tmp<Field<Type>>();
} }

4
src/OpenFOAM/memory/refCount/refCount.H
View File

@ -53,6 +53,10 @@ class refCount
public: public:
//- A non-counting (dummy) refCount
struct zero {};
// Constructors // Constructors
//- Construct null initializing count to 0 //- Construct null initializing count to 0

200
src/OpenFOAM/memory/tmp/tmp.H
View File

@ -3,7 +3,7 @@
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox \\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | \\ / O peration |
\\ / A nd | Copyright (C) 2011-2016 OpenFOAM Foundation \\ / A nd | Copyright (C) 2011-2016 OpenFOAM Foundation
\\/ M anipulation | \\/ M anipulation | Copyright (C) 2018 OpenCFD Ltd.
------------------------------------------------------------------------------- -------------------------------------------------------------------------------
License License
This file is part of OpenFOAM. This file is part of OpenFOAM.
@ -25,14 +25,19 @@ Class
Foam::tmp Foam::tmp
Description Description
A class for managing temporary objects A class for managing temporary objects.
This is a combination of std::shared_ptr (with intrusive ref-counting)
and a shared_ptr without ref-counting and null deleter.
This allows the tmp to double as a pointer management and an indirect
pointer to externally allocated objects.
SourceFiles SourceFiles
tmpI.H tmpI.H
See also See also
Foam::refCount
Foam::autoPtr Foam::autoPtr
Foam::refCount
\*---------------------------------------------------------------------------*/ \*---------------------------------------------------------------------------*/
@ -41,6 +46,7 @@ See also
#include "refCount.H" #include "refCount.H"
#include "word.H" #include "word.H"
#include <utility>
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
@ -57,111 +63,201 @@ class tmp
// Private data // Private data
//- Object types //- Object types
enum type enum refType
{ {
TMP, PTR, //!< Managing a (ref-counted) pointer
CONST_REF CREF //!< Using a const-reference to an object
}; };
//- Pointer to object //- The managed pointer or the address of const-reference object
mutable T* ptr_; mutable T* ptr_;
//- Type of object //- The type (managed pointer | const-reference object)
type type_; mutable refType type_;
// Private member operators // Private Member Operators
//- Increment the ref-count for a managed pointer
inline void operator++(); inline void operator++();
public: public:
typedef T Type; // STL type definitions
//- Type of object being managed or referenced
typedef T element_type;
//- Pointer to type of object being managed or referenced
typedef T* pointer;
//- Reference counter class
typedef Foam::refCount refCount; typedef Foam::refCount refCount;
// Factory Methods
//- Construct tmp of T with forwarding arguments
// \param args list of arguments with which an instance of T
// will be constructed.
//
// \note Similar to std::make_shared, but the overload for
// array types is not disabled.
template<class... Args>
inline static tmp<T> New(Args&&... args);
//- Construct tmp from derived type with forwarding arguments
// \param args list of arguments with which an instance of U
// will be constructed.
//
// \note Similar to New but for derived types
template<class U, class... Args>
inline static tmp<T> NewFrom(Args&&... args);
// Constructors // Constructors
//- Null pointer construct //- Construct with no managed pointer.
inline tmp(); inline constexpr tmp() noexcept;
//- Store object pointer //- Construct with no managed pointer.
inline constexpr tmp(std::nullptr_t) noexcept;
//- Construct, taking ownership of the pointer.
inline explicit tmp(T* p); inline explicit tmp(T* p);
//- Store object const reference //- Construct for a const reference to an object.
inline tmp(const T& t); inline tmp(const T& obj) noexcept;
//- Construct copy and increment reference count //- Move construct, transferring ownership.
// Does not affect ref-count
inline tmp(tmp<T>&& t) noexcept;
//- Move construct, transferring ownership.
// Does not affect ref-count
// \note Non-standard definition - should be non-const
inline tmp(const tmp<T>&& t) noexcept;
//- Copy construct, incrementing ref-count of managed pointer.
// \note Non-standard definition - should be non-const
inline tmp(const tmp<T>& t); inline tmp(const tmp<T>& t);
//- Construct copy moving content, does not increment reference count //- Copy construct. Optionally reusing ref-counted pointer.
inline tmp(const tmp<T>&& t); inline tmp(const tmp<T>& t, bool reuse);
//- Construct copy transferring content of temporary if required
inline tmp(const tmp<T>& t, bool allowTransfer);
//- Destructor: deletes temporary object when the reference count is 0 //- Destructor: deletes managed pointer when the ref-count is 0
inline ~tmp(); inline ~tmp();
// Member Functions // Member Functions
// Access // Query
//- Return true if this is really a temporary object //- True if this is a managed pointer (not a const reference)
inline bool isTmp() const; inline bool isTmp() const;
//- Return true if this temporary object empty, //- True if this is a non-null managed pointer
// ie, a temporary without allocation inline bool empty() const;
inline bool empty() const;
//- Is this temporary object valid, //- True if this is a non-null managed pointer,
// ie, it is a reference or a temporary that has been allocated //- or is a const object reference
inline bool valid() const; inline bool valid() const;
//- Return the type name of the tmp //- True if this is a non-null managed pointer with a unique ref-count
// constructed from the type name of T inline bool movable() const;
inline word typeName() const;
//- Return type-name of the tmp, constructed from type-name of T
inline word typeName() const;
// Edit // Access
//- Return tmp pointer for reuse. //- Return the const object reference or a const reference to the
// Returns a clone if the object is not a temporary //- contents of a non-null managed pointer.
inline T* ptr() const; // Fatal for a null managed pointer
inline const T& cref() const;
//- Return non-const reference. Fatal if the object is const. //- Return non-const reference to the contents of a non-null
inline T& ref() const; //- managed pointer.
// Fatal for a null managed pointer or if the object is const.
inline T& ref() const;
//- If object pointer points to valid object: //- Non-const dereference, even if the object is const.
//- delete object and set pointer to nullptr // This is similar to ref(), but applies a const_cast to access
inline void clear() const; // const objects.
// Fatal for a null managed pointer.
inline T& constCast() const;
// Edit
//- Return managed pointer for reuse, or clone() the const object
//- reference.
inline T* ptr() const;
//- If object pointer points to valid object:
//- delete object and set pointer to nullptr
inline void clear() const;
//- Release ownership of managed temporary object.
// After this call no object is managed.
inline void reset();
//- Delete managed temporary object and set to new given pointer
inline void reset(T* p);
//- Swaps the managed object with other tmp.
inline void swap(tmp<T>& other) noexcept;
// Member operators // Member operators
//- Const dereference operator //- Return const reference to the object.
// Identical to cref() method.
inline const T& operator()() const; inline const T& operator()() const;
//- Const cast to the underlying type reference //- Cast to underlying data type, using the cref() method.
inline operator const T&() const; inline operator const T&() const;
//- Return object pointer //- Dereferences (const) pointer to the managed object.
inline T* operator->(); // Fatal for a null managed pointer.
//- Return const object pointer
inline const T* operator->() const; inline const T* operator->() const;
//- Assignment to pointer changing this tmp to a temporary T //- Dereferences (non-const) pointer to the managed object.
// Fatal for a null managed pointer or if the object is const.
inline T* operator->();
//- Take ownership of the pointer.
// Fatal for a null pointer, or when the pointer is non-unique.
inline void operator=(T* p); inline void operator=(T* p);
//- Assignment transferring the temporary T to this tmp //- Transfer ownership of the managed pointer.
// Fatal for a null managed pointer or if the object is const.
inline void operator=(const tmp<T>& t); inline void operator=(const tmp<T>& t);
// Housekeeping
//- Disallow assignment from literal nullptr.
// Consistent with run-time check for nullptr on assignment.
void operator=(std::nullptr_t) = delete;
}; };
// Global Functions
//- Specializes the Swap algorithm for tmp.
// Swaps the pointers and types of lhs and rhs. Calls \c lhs.swap(rhs)
template<class T>
void Swap(tmp<T>& lhs, tmp<T>& rhs)
{
lhs.swap(rhs);
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam } // End namespace Foam

252
src/OpenFOAM/memory/tmp/tmpI.H
View File

@ -3,7 +3,7 @@
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox \\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | \\ / O peration |
\\ / A nd | Copyright (C) 2011-2017 OpenFOAM Foundation \\ / A nd | Copyright (C) 2011-2017 OpenFOAM Foundation
\\/ M anipulation | \\/ M anipulation | Copyright (C) 2018 OpenCFD Ltd.
------------------------------------------------------------------------------- -------------------------------------------------------------------------------
License License
This file is part of OpenFOAM. This file is part of OpenFOAM.
@ -43,13 +43,39 @@ inline void Foam::tmp<T>::operator++()
} }
// * * * * * * * * * * * * * Static Member Functions * * * * * * * * * * * * //
template<class T>
template<class... Args>
inline Foam::tmp<T> Foam::tmp<T>::New(Args&&... args)
{
return tmp<T>(new T(std::forward<Args>(args)...));
}
template<class T>
template<class U, class... Args>
inline Foam::tmp<T> Foam::tmp<T>::NewFrom(Args&&... args)
{
return tmp<T>(new U(std::forward<Args>(args)...));
}
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
template<class T> template<class T>
inline Foam::tmp<T>::tmp() inline constexpr Foam::tmp<T>::tmp() noexcept
: :
ptr_(nullptr), ptr_(nullptr),
type_(TMP) type_(PTR)
{}
template<class T>
inline constexpr Foam::tmp<T>::tmp(std::nullptr_t) noexcept
:
ptr_(nullptr),
type_(PTR)
{} {}
@ -57,7 +83,7 @@ template<class T>
inline Foam::tmp<T>::tmp(T* p) inline Foam::tmp<T>::tmp(T* p)
: :
ptr_(p), ptr_(p),
type_(TMP) type_(PTR)
{ {
if (p && !p->unique()) if (p && !p->unique())
{ {
@ -70,13 +96,35 @@ inline Foam::tmp<T>::tmp(T* p)
template<class T> template<class T>
inline Foam::tmp<T>::tmp(const T& t) inline Foam::tmp<T>::tmp(const T& obj) noexcept
: :
ptr_(const_cast<T*>(&t)), ptr_(const_cast<T*>(&obj)),
type_(CONST_REF) type_(CREF)
{} {}
template<class T>
inline Foam::tmp<T>::tmp(tmp<T>&& t) noexcept
:
ptr_(t.ptr_),
type_(t.type_)
{
t.ptr_ = nullptr;
t.type_ = PTR;
}
template<class T>
inline Foam::tmp<T>::tmp(const tmp<T>&& t) noexcept
:
ptr_(t.ptr_),
type_(t.type_)
{
t.ptr_ = nullptr;
t.type_ = PTR;
}
template<class T> template<class T>
inline Foam::tmp<T>::tmp(const tmp<T>& t) inline Foam::tmp<T>::tmp(const tmp<T>& t)
: :
@ -100,20 +148,7 @@ inline Foam::tmp<T>::tmp(const tmp<T>& t)
template<class T> template<class T>
inline Foam::tmp<T>::tmp(const tmp<T>&& t) inline Foam::tmp<T>::tmp(const tmp<T>& t, bool reuse)
:
ptr_(t.ptr_),
type_(t.type_)
{
if (isTmp())
{
t.ptr_ = nullptr;
}
}
template<class T>
inline Foam::tmp<T>::tmp(const tmp<T>& t, bool allowTransfer)
: :
ptr_(t.ptr_), ptr_(t.ptr_),
type_(t.type_) type_(t.type_)
@ -122,9 +157,9 @@ inline Foam::tmp<T>::tmp(const tmp<T>& t, bool allowTransfer)
{ {
if (ptr_) if (ptr_)
{ {
if (allowTransfer) if (reuse)
{ {
t.ptr_ = nullptr; t.ptr_ = nullptr; // t.type_ already set as PTR
} }
else else
{ {
@ -153,21 +188,28 @@ inline Foam::tmp<T>::~tmp()
template<class T> template<class T>
inline bool Foam::tmp<T>::isTmp() const inline bool Foam::tmp<T>::isTmp() const
{ {
return type_ == TMP; return type_ == PTR;
} }
template<class T> template<class T>
inline bool Foam::tmp<T>::empty() const inline bool Foam::tmp<T>::empty() const
{ {
return (isTmp() && !ptr_); return (!ptr_ && isTmp());
} }
template<class T> template<class T>
inline bool Foam::tmp<T>::valid() const inline bool Foam::tmp<T>::valid() const
{ {
return (!isTmp() || (isTmp() && ptr_)); return (ptr_ || type_ == CREF);
}
template<class T>
inline bool Foam::tmp<T>::movable() const
{
return (type_ == PTR && ptr_ && ptr_->unique());
} }
@ -179,7 +221,7 @@ inline Foam::word Foam::tmp<T>::typeName() const
template<class T> template<class T>
inline T* Foam::tmp<T>::ptr() const inline const T& Foam::tmp<T>::cref() const
{ {
if (isTmp()) if (isTmp())
{ {
@ -189,22 +231,9 @@ inline T* Foam::tmp<T>::ptr() const
<< typeName() << " deallocated" << typeName() << " deallocated"
<< abort(FatalError); << abort(FatalError);
} }
if (!ptr_->unique())
{
FatalErrorInFunction
<< "Attempt to acquire pointer to object referred to"
<< " by multiple temporaries of type " << typeName()
<< abort(FatalError);
}
T* ptr = ptr_;
ptr_ = nullptr;
return ptr;
} }
return ptr_->clone().ptr(); return *ptr_; // const reference
} }
@ -223,12 +252,55 @@ inline T& Foam::tmp<T>::ref() const
else else
{ {
FatalErrorInFunction FatalErrorInFunction
<< "Attempt to acquire non-const reference to const object" << "Attempted non-const reference to const object from a "
<< " from a " << typeName() << typeName()
<< abort(FatalError); << abort(FatalError);
} }
return *ptr_; return *ptr_; // non-const reference
}
template<class T>
inline T& Foam::tmp<T>::constCast() const
{
if (isTmp() && !ptr_)
{
FatalErrorInFunction
<< typeName() << " deallocated"
<< abort(FatalError);
}
return const_cast<T&>(*ptr_);
}
template<class T>
inline T* Foam::tmp<T>::ptr() const
{
if (isTmp())
{
if (!ptr_)
{
FatalErrorInFunction
<< typeName() << " deallocated"
<< abort(FatalError);
}
else if (!ptr_->unique())
{
FatalErrorInFunction
<< "Attempt to acquire pointer to object referred to"
<< " by multiple temporaries of type " << typeName()
<< abort(FatalError);
}
T* ptr = ptr_;
ptr_ = nullptr;
return ptr;
}
return ptr_->clone().ptr();
} }
@ -240,41 +312,75 @@ inline void Foam::tmp<T>::clear() const
if (ptr_->unique()) if (ptr_->unique())
{ {
delete ptr_; delete ptr_;
ptr_ = nullptr;
} }
else else
{ {
ptr_->operator--(); ptr_->operator--();
ptr_ = nullptr;
} }
ptr_ = nullptr;
} }
} }
template<class T>
inline void Foam::tmp<T>::reset()
{
clear();
ptr_ = nullptr;
type_ = PTR;
}
template<class T>
inline void Foam::tmp<T>::reset(T* p)
{
clear();
ptr_ = p;
type_ = PTR;
}
template<class T>
inline void Foam::tmp<T>::swap(tmp<T>& other) noexcept
{
// Copy/assign for pointer types
T* p = ptr_;
ptr_ = other.ptr_;
other.ptr_ = p;
refType t = type_;
type_ = other.type_;
other.type_ = t;
}
// * * * * * * * * * * * * * * * Member Operators * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * Member Operators * * * * * * * * * * * * * //
template<class T> template<class T>
inline const T& Foam::tmp<T>::operator()() const inline const T& Foam::tmp<T>::operator()() const
{ {
if (isTmp()) return cref();
{
if (!ptr_)
{
FatalErrorInFunction
<< typeName() << " deallocated"
<< abort(FatalError);
}
}
// Return const reference
return *ptr_;
} }
template<class T> template<class T>
inline Foam::tmp<T>::operator const T&() const inline Foam::tmp<T>::operator const T&() const
{ {
return operator()(); return cref();
}
template<class T>
inline const T* Foam::tmp<T>::operator->() const
{
if (!ptr_ && isTmp())
{
FatalErrorInFunction
<< typeName() << " deallocated"
<< abort(FatalError);
}
return ptr_;
} }
@ -301,20 +407,6 @@ inline T* Foam::tmp<T>::operator->()
} }
template<class T>
inline const T* Foam::tmp<T>::operator->() const
{
if (isTmp() && !ptr_)
{
FatalErrorInFunction
<< typeName() << " deallocated"
<< abort(FatalError);
}
return ptr_;
}
template<class T> template<class T>
inline void Foam::tmp<T>::operator=(T* p) inline void Foam::tmp<T>::operator=(T* p)
{ {
@ -326,8 +418,7 @@ inline void Foam::tmp<T>::operator=(T* p)
<< "Attempted copy of a deallocated " << typeName() << "Attempted copy of a deallocated " << typeName()
<< abort(FatalError); << abort(FatalError);
} }
else if (!p->unique())
if (p && !p->unique())
{ {
FatalErrorInFunction FatalErrorInFunction
<< "Attempted assignment of a " << typeName() << "Attempted assignment of a " << typeName()
@ -336,7 +427,7 @@ inline void Foam::tmp<T>::operator=(T* p)
} }
ptr_ = p; ptr_ = p;
type_ = TMP; type_ = PTR;
} }
@ -347,17 +438,16 @@ inline void Foam::tmp<T>::operator=(const tmp<T>& t)
if (t.isTmp()) if (t.isTmp())
{ {
type_ = TMP; ptr_ = t.ptr_;
type_ = PTR;
t.ptr_ = nullptr;
if (!t.ptr_) if (!ptr_)
{ {
FatalErrorInFunction FatalErrorInFunction
<< "Attempted assignment to a deallocated " << typeName() << "Attempted assignment to a deallocated " << typeName()
<< abort(FatalError); << abort(FatalError);
} }
ptr_ = t.ptr_;
t.ptr_ = nullptr;
} }
else else
{ {

214
src/OpenFOAM/memory/tmp/tmpNrc.H Normal file
View File

@ -0,0 +1,214 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2016 OpenFOAM Foundation
\\/ M anipulation | Copyright (C) 2018 OpenCFD Ltd.
-------------------------------------------------------------------------------
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
See also
Foam::autoPtr
\*---------------------------------------------------------------------------*/
#ifndef tmpNrc_H
#define tmpNrc_H
#include "refCount.H"
#include "word.H"
#include <utility>
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
/*---------------------------------------------------------------------------*\
Class tmpNrc Declaration
\*---------------------------------------------------------------------------*/
template<class T>
class tmpNrc
{
// Private data
//- Object types
enum refType
{
PTR, //!< Managing a pointer (not ref-counted)
CREF //!< Using a const-reference to an object
};
//- The managed pointer or the address of const-reference object
mutable T* ptr_;
//- The type (managed pointer | const-reference object)
refType type_;
public:
// STL type definitions
//- Type of object being managed
typedef T element_type;
//- Pointer to type of object being managed
typedef T* pointer;
//- Null reference counter class
typedef Foam::refCount::zero refCount;
// Constructors
//- Construct with no managed pointer.
inline constexpr tmpNrc() noexcept;
//- Construct with no managed pointer.
inline constexpr tmpNrc(std::nullptr_t) noexcept;
//- Construct, taking ownership of the pointer.
inline explicit tmpNrc(T* p) noexcept;
//- Construct for a const reference to an object.
inline tmpNrc(const T& obj) noexcept;
//- Copy construct
inline tmpNrc(const tmpNrc<T>& t);
//- Construct copy, transferring content of temporary if required
inline tmpNrc(const tmpNrc<T>& t, bool reuse);
//- Destructor: deletes managed pointer
inline ~tmpNrc();
// Member Functions
// Query
//- True if this is a managed pointer (not a const reference)
inline bool isTmp() const;
//- True if this is a non-null managed pointer
inline bool empty() const;
//- True if this is a non-null managed pointer,
//- or is a const object reference
inline bool valid() const;
//- True if this is a non-null managed pointer with a unique ref-count
inline bool movable() const;
//- Return type-name of the tmp, constructed from type-name of T
inline word typeName() const;
// Access
//- Return the const object reference or a const reference to the
//- contents of a non-null managed pointer.
// Fatal for a null managed pointer
inline const T& cref() const;
//- Return non-const reference to the contents of a non-null
//- managed pointer.
// Fatal for a null managed pointer or if the object is const.
inline T& ref() const;
//- Non-const dereference, even if the object is const.
// This is similar to ref(), but applies a const_cast to access
// const objects.
// Fatal for a null managed pointer.
inline T& constCast() const;
// Edit
//- Return managed pointer for reuse, or clone() the const object
//- reference.
inline T* ptr() const;
//- If object pointer points to valid object:
//- delete object and set pointer to nullptr
inline void clear() const;
// Member operators
//- Return const reference to the object.
// Identical to cref() method.
inline const T& operator()() const;
//- Cast to underlying data type, using the cref() method.
inline operator const T&() const;
//- Dereferences (const) pointer to the managed object.
// Fatal for a null managed pointer.
inline const T* operator->() const;
//- Dereferences (non-const) pointer to the managed object.
// Fatal for a null managed pointer or if the object is const.
inline T* operator->();
//- Take ownership of the pointer.
// Fatal for a null pointer, or when the pointer is non-unique.
inline void operator=(T* p);
//- Transfer ownership of the managed pointer.
// Fatal for a null managed pointer or if the object is const.
inline void operator=(const tmpNrc<T>& t);
};
// Global Functions
//- Specializes the Swap algorithm for tmp.
// Swaps the pointers and types of lhs and rhs. Calls \c lhs.swap(rhs)
template<class T>
void Swap(tmpNrc<T>& lhs, tmpNrc<T>& rhs)
{
lhs.swap(rhs);
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#include "tmpNrcI.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //

180
src/OpenFOAM/memory/tmpNrc/tmpNrcI.H → src/OpenFOAM/memory/tmp/tmpNrcI.H
View File

@ -3,7 +3,7 @@
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox \\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | \\ / O peration |
\\ / A nd | Copyright (C) 2016-2017 OpenFOAM Foundation \\ / A nd | Copyright (C) 2016-2017 OpenFOAM Foundation
\\/ M anipulation | \\/ M anipulation | Copyright (C) 2018 OpenCFD Ltd.
------------------------------------------------------------------------------- -------------------------------------------------------------------------------
License License
This file is part of OpenFOAM. This file is part of OpenFOAM.
@ -29,32 +29,48 @@ License
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
template<class T> template<class T>
inline Foam::tmpNrc<T>::tmpNrc(T* tPtr) inline constexpr Foam::tmpNrc<T>::tmpNrc() noexcept
: :
type_(TMP), ptr_(nullptr),
ptr_(tPtr) type_(PTR)
{} {}
template<class T> template<class T>
inline Foam::tmpNrc<T>::tmpNrc(const T& tRef) inline constexpr Foam::tmpNrc<T>::tmpNrc(std::nullptr_t) noexcept
: :
type_(CONST_REF), ptr_(nullptr),
ptr_(const_cast<T*>(&tRef)) type_(PTR)
{}
template<class T>
inline Foam::tmpNrc<T>::tmpNrc(T* p) noexcept
:
ptr_(p),
type_(PTR)
{}
template<class T>
inline Foam::tmpNrc<T>::tmpNrc(const T& obj) noexcept
:
ptr_(const_cast<T*>(&obj)),
type_(CREF)
{} {}
template<class T> template<class T>
inline Foam::tmpNrc<T>::tmpNrc(const tmpNrc<T>& t) inline Foam::tmpNrc<T>::tmpNrc(const tmpNrc<T>& t)
: :
type_(t.type_), ptr_(t.ptr_),
ptr_(t.ptr_) type_(t.type_)
{ {
if (isTmp()) if (isTmp())
{ {
if (ptr_) if (ptr_)
{ {
t.type_ = CONST_REF; t.type_ = CREF;
} }
else else
{ {
@ -67,22 +83,22 @@ inline Foam::tmpNrc<T>::tmpNrc(const tmpNrc<T>& t)
template<class T> template<class T>
inline Foam::tmpNrc<T>::tmpNrc(const tmpNrc<T>& t, bool allowTransfer) inline Foam::tmpNrc<T>::tmpNrc(const tmpNrc<T>& t, bool reuse)
: :
type_(t.type_), ptr_(t.ptr_),
ptr_(t.ptr_) type_(t.type_)
{ {
if (isTmp()) if (isTmp())
{ {
if (ptr_) if (ptr_)
{ {
if (allowTransfer) if (reuse)
{ {
t.ptr_ = nullptr; t.ptr_ = nullptr; // t.type_ already set as PTR
} }
else else
{ {
t.type_ = CONST_REF; t.type_ = CREF;
} }
} }
else else
@ -107,21 +123,28 @@ inline Foam::tmpNrc<T>::~tmpNrc()
template<class T> template<class T>
inline bool Foam::tmpNrc<T>::isTmp() const inline bool Foam::tmpNrc<T>::isTmp() const
{ {
return type_ == TMP; return type_ == PTR;
} }
template<class T> template<class T>
inline bool Foam::tmpNrc<T>::empty() const inline bool Foam::tmpNrc<T>::empty() const
{ {
return (isTmp() && !ptr_); return (!ptr_ && isTmp());
} }
template<class T> template<class T>
inline bool Foam::tmpNrc<T>::valid() const inline bool Foam::tmpNrc<T>::valid() const
{ {
return (!isTmp() || (isTmp() && ptr_)); return (ptr_ || type_ == CREF);
}
template<class T>
inline bool Foam::tmpNrc<T>::movable() const
{
return (type_ == PTR && ptr_);
} }
@ -133,7 +156,24 @@ inline Foam::word Foam::tmpNrc<T>::typeName() const
template<class T> template<class T>
inline T& Foam::tmpNrc<T>::ref() inline const T& Foam::tmpNrc<T>::cref() const
{
if (isTmp())
{
if (!ptr_)
{
FatalErrorInFunction
<< typeName() << " deallocated"
<< abort(FatalError);
}
}
return *ptr_; // const reference
}
template<class T>
inline T& Foam::tmpNrc<T>::ref() const
{ {
if (isTmp()) if (isTmp())
{ {
@ -147,12 +187,26 @@ inline T& Foam::tmpNrc<T>::ref()
else else
{ {
FatalErrorInFunction FatalErrorInFunction
<< "Attempt to acquire non-const reference to const object" << "Attempted non-const reference to const object from a "
<< " from a " << typeName() << typeName()
<< abort(FatalError); << abort(FatalError);
} }
return *ptr_; return *ptr_; // non-const reference
}
template<class T>
inline T& Foam::tmpNrc<T>::constCast() const
{
if (isTmp() && !ptr_)
{
FatalErrorInFunction
<< typeName() << " deallocated"
<< abort(FatalError);
}
return const_cast<T&>(*ptr_);
} }
@ -173,10 +227,8 @@ inline T* Foam::tmpNrc<T>::ptr() const
return ptr; return ptr;
} }
else
{ return ptr_->clone().ptr();
return ptr_->clone().ptr();
}
} }
@ -191,30 +243,47 @@ inline void Foam::tmpNrc<T>::clear() const
} }
template<class T>
inline void Foam::tmpNrc<T>::swap(tmpNrc<T>& other) noexcept
{
// Copy/assign for pointer types
T* p = ptr_;
ptr_ = other.ptr_;
other.ptr_ = p;
refType t = type_;
type_ = other.type_;
other.type_ = t;
}
// * * * * * * * * * * * * * * * Member Operators * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * Member Operators * * * * * * * * * * * * * //
template<class T> template<class T>
inline const T& Foam::tmpNrc<T>::operator()() const inline const T& Foam::tmpNrc<T>::operator()() const
{ {
if (isTmp()) return cref();
{
if (!ptr_)
{
FatalErrorInFunction
<< typeName() << " deallocated"
<< abort(FatalError);
}
}
// Return const reference
return *ptr_;
} }
template<class T> template<class T>
inline Foam::tmpNrc<T>::operator const T&() const inline Foam::tmpNrc<T>::operator const T&() const
{ {
return operator()(); return cref();
}
template<class T>
inline const T* Foam::tmpNrc<T>::operator->() const
{
if (!ptr_ && isTmp())
{
FatalErrorInFunction
<< typeName() << " deallocated"
<< abort(FatalError);
}
return ptr_;
} }
@ -242,33 +311,19 @@ inline T* Foam::tmpNrc<T>::operator->()
template<class T> template<class T>
inline const T* Foam::tmpNrc<T>::operator->() const inline void Foam::tmpNrc<T>::operator=(T* p)
{
if (isTmp() && !ptr_)
{
FatalErrorInFunction
<< typeName() << " deallocated"
<< abort(FatalError);
}
return ptr_;
}
template<class T>
inline void Foam::tmpNrc<T>::operator=(T* tPtr)
{ {
clear(); clear();
if (!tPtr) if (!p)
{ {
FatalErrorInFunction FatalErrorInFunction
<< "Attempted copy of a deallocated " << typeName() << "Attempted copy of a deallocated " << typeName()
<< abort(FatalError); << abort(FatalError);
} }
type_ = TMP; ptr_ = p;
ptr_ = tPtr; type_ = PTR;
} }
@ -279,17 +334,16 @@ inline void Foam::tmpNrc<T>::operator=(const tmpNrc<T>& t)
if (t.isTmp()) if (t.isTmp())
{ {
type_ = TMP; ptr_ = t.ptr_;
type_ = PTR;
t.ptr_ = nullptr;
if (!t.ptr_) if (!ptr_)
{ {
FatalErrorInFunction FatalErrorInFunction
<< "Attempted assignment to a deallocated " << typeName() << "Attempted assignment to a deallocated " << typeName()
<< abort(FatalError); << abort(FatalError);
} }
ptr_ = t.ptr_;
t.ptr_ = nullptr;
} }
else else
{ {

171
src/OpenFOAM/memory/tmpNrc/tmpNrc.H
View File

@ -1,171 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / 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
See also
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* tPtr = nullptr);
//- Store object const reference
inline tmpNrc(const T& tRef);
//- Construct copy and increment reference count
inline tmpNrc(const tmpNrc<T>& t);
//- Construct copy transferring content of temporary if required
inline tmpNrc(const tmpNrc<T>& 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 nullptr
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* tPtr);
//- Assignment transferring the temporary T to this tmpNrc
inline void operator=(const tmpNrc<T>& t);
};
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#include "tmpNrcI.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //

6
src/OpenFOAM/primitives/functions/Function1/Function1/Function1.C
View File

@ -79,8 +79,7 @@ Foam::tmp<Foam::Field<Type>> Foam::Function1<Type>::value
) const ) const
{ {
NotImplemented; NotImplemented;
return tmp<Field<Type>>();
return tmp<Foam::Field<Type>>(nullptr);
} }
@ -101,8 +100,7 @@ Foam::tmp<Foam::Field<Type>> Foam::Function1<Type>::integrate
) const ) const
{ {
NotImplemented; NotImplemented;
return tmp<Field<Type>>();
return tmp<Foam::Field<Type>>(nullptr);
} }

23
src/TurbulenceModels/schemes/DEShybrid/DEShybrid.H
View File

@ -417,15 +417,13 @@ public:
vf, model.muEff()/model.rho(), model.U(), delta vf, model.muEff()/model.rho(), model.U(), delta
); );
} }
else
{
FatalErrorInFunction
<< "Scheme requires a turbulence model to be present. "
<< "Unable to retrieve turbulence model from the mesh "
<< "database" << exit(FatalError);
return tmp<surfaceScalarField>(nullptr); FatalErrorInFunction
} << "Scheme requires a turbulence model to be present. "
<< "Unable to retrieve turbulence model from the mesh "
<< "database" << exit(FatalError);
return tmp<surfaceScalarField>();
} }
@ -501,13 +499,8 @@ public:
{ {
return (bf*tScheme2_().correction(vf)); return (bf*tScheme2_().correction(vf));
} }
else
{ return tmp<GeometricField<Type, fvsPatchField, surfaceMesh>>();
return tmp<GeometricField<Type, fvsPatchField, surfaceMesh>>
(
nullptr
);
}
} }
}; };

2
src/TurbulenceModels/turbulenceModels/LES/LESfilters/LESfilter/LESfilter.H
View File

@ -79,7 +79,7 @@ protected:
template<class GeoFieldType> template<class GeoFieldType>
void correctBoundaryConditions(const tmp<GeoFieldType>& tgf) const void correctBoundaryConditions(const tmp<GeoFieldType>& tgf) const
{ {
const_cast<GeoFieldType&>(tgf()).correctBoundaryConditions(); tgf.constCast().correctBoundaryConditions();
} }

2
src/finiteArea/finiteArea/lnGradSchemes/lnGradScheme/lnGradScheme.H
View File

@ -148,7 +148,7 @@ public:
virtual tmp<GeometricField<Type, faePatchField, edgeMesh>> virtual tmp<GeometricField<Type, faePatchField, edgeMesh>>
correction(const GeometricField<Type, faPatchField, areaMesh>&) const correction(const GeometricField<Type, faPatchField, areaMesh>&) const
{ {
return tmp<GeometricField<Type, faePatchField, edgeMesh>>(nullptr); return tmp<GeometricField<Type, faePatchField, edgeMesh>>();
} }
//- Return the lnGrad of the given cell field //- Return the lnGrad of the given cell field

2
src/finiteArea/interpolation/edgeInterpolation/edgeInterpolationScheme/edgeInterpolationScheme.H
View File

@ -189,7 +189,7 @@ public:
virtual tmp<GeometricField<Type, faePatchField, edgeMesh>> virtual tmp<GeometricField<Type, faePatchField, edgeMesh>>
correction(const GeometricField<Type, faPatchField, areaMesh>&) const correction(const GeometricField<Type, faPatchField, areaMesh>&) const
{ {
return tmp<GeometricField<Type, faePatchField, edgeMesh>>(nullptr); return tmp<GeometricField<Type, faePatchField, edgeMesh>>();
} }
//- Return the face-interpolate of the given cell field //- Return the face-interpolate of the given cell field

12
src/finiteVolume/finiteVolume/ddtSchemes/CoEulerDdtScheme/CoEulerDdtScheme.C
View File

@ -135,14 +135,12 @@ tmp<surfaceScalarField> CoEulerDdtScheme<Type>::CofrDeltaT() const
return max(Co/maxCo_, scalar(1))/deltaT; return max(Co/maxCo_, scalar(1))/deltaT;
} }
else
{
FatalErrorInFunction
<< "Incorrect dimensions of phi: " << phi.dimensions()
<< abort(FatalError);
return tmp<surfaceScalarField>(nullptr); FatalErrorInFunction
} << "Incorrect dimensions of phi: " << phi.dimensions()
<< abort(FatalError);
return tmp<surfaceScalarField>();
} }

7
src/finiteVolume/fvMesh/fvPatches/derived/regionCoupled/regionCoupledFvPatch.C
View File

@ -56,13 +56,8 @@ Foam::tmp<Foam::labelField> Foam::regionCoupledFvPatch::internalFieldTransfer
{ {
return neighbFvPatch().patchInternalField(iF); return neighbFvPatch().patchInternalField(iF);
} }
else
{
return tmp<labelField>(new labelField(iF.size(), 0));
} return tmp<labelField>(new labelField(iF.size(), 0));
return tmp<labelField>(nullptr);
} }

6
src/finiteVolume/fvMesh/fvPatches/derived/regionCoupled/regionCoupledWallFvPatch.C
View File

@ -58,12 +58,8 @@ internalFieldTransfer
{ {
return neighbFvPatch().patchInternalField(iF); return neighbFvPatch().patchInternalField(iF);
} }
else
{
return tmp<labelField>(new labelField(iF.size(), 0));
} return tmp<labelField>(new labelField(iF.size(), 0));
return tmp<labelField>(nullptr);
} }
// ************************************************************************* // // ************************************************************************* //

24
src/functionObjects/field/heatTransferCoeff/heatTransferCoeffModels/ReynoldsAnalogy/ReynoldsAnalogy.C
View File

@ -62,14 +62,12 @@ Foam::heatTransferCoeffModels::ReynoldsAnalogy::rho(const label patchi) const
mesh_.lookupObject<volScalarField>(rhoName_); mesh_.lookupObject<volScalarField>(rhoName_);
return rho.boundaryField()[patchi]; return rho.boundaryField()[patchi];
} }
else
{
FatalErrorInFunction
<< "Unable to set rho for patch " << patchi
<< exit(FatalError);
}
return tmp<Field<scalar>>(nullptr); FatalErrorInFunction
<< "Unable to set rho for patch " << patchi
<< exit(FatalError);
return tmp<Field<scalar>>();
} }
@ -91,14 +89,12 @@ Foam::heatTransferCoeffModels::ReynoldsAnalogy::Cp(const label patchi) const
return thermo.Cp(pp, Tp, patchi); return thermo.Cp(pp, Tp, patchi);
} }
else
{
FatalErrorInFunction
<< "Unable to set Cp for patch " << patchi
<< exit(FatalError);
}
return tmp<Field<scalar>>(nullptr); FatalErrorInFunction
<< "Unable to set Cp for patch " << patchi
<< exit(FatalError);
return tmp<Field<scalar>>();
} }

2
src/fvOptions/sources/derived/solidificationMeltingSource/solidificationMeltingSource.C
View File

@ -119,7 +119,7 @@ Foam::fv::solidificationMeltingSource::Cp() const
} }
} }
return tmp<volScalarField>(nullptr); return tmp<volScalarField>();
} }

3
src/lagrangian/intermediate/submodels/MPPIC/ParticleStressModels/Lun/Lun.C
View File

@ -109,8 +109,7 @@ Foam::ParticleStressModels::Lun::dTaudTheta
) const ) const
{ {
NotImplemented; NotImplemented;
return tmp<Field<scalar>>();
return tmp<Field<scalar>>(nullptr);
} }

28
src/lagrangian/turbulence/submodels/Kinematic/DispersionModel/DispersionRASModel/DispersionRASModel.C
View File

@ -47,15 +47,13 @@ Foam::DispersionRASModel<CloudType>::kModel() const
obr.lookupObject<turbulenceModel>(turbName); obr.lookupObject<turbulenceModel>(turbName);
return model.k(); return model.k();
} }
else
{
FatalErrorInFunction
<< "Turbulence model not found in mesh database" << nl
<< "Database objects include: " << obr.sortedToc()
<< abort(FatalError);
return tmp<volScalarField>(nullptr); FatalErrorInFunction
} << "Turbulence model not found in mesh database" << nl
<< "Database objects include: " << obr.sortedToc()
<< abort(FatalError);
return tmp<volScalarField>();
} }
@ -77,15 +75,13 @@ Foam::DispersionRASModel<CloudType>::epsilonModel() const
obr.lookupObject<turbulenceModel>(turbName); obr.lookupObject<turbulenceModel>(turbName);
return model.epsilon(); return model.epsilon();
} }
else
{
FatalErrorInFunction
<< "Turbulence model not found in mesh database" << nl
<< "Database objects include: " << obr.sortedToc()
<< abort(FatalError);
return tmp<volScalarField>(nullptr); FatalErrorInFunction
} << "Turbulence model not found in mesh database" << nl
<< "Database objects include: " << obr.sortedToc()
<< abort(FatalError);
return tmp<volScalarField>();
} }

14
src/lagrangian/turbulence/submodels/Thermodynamic/ParticleForces/BrownianMotion/BrownianMotionForce.C
View File

@ -70,15 +70,13 @@ Foam::BrownianMotionForce<CloudType>::kModel() const
obr.lookupObject<turbulenceModel>(turbName); obr.lookupObject<turbulenceModel>(turbName);
return model.k(); return model.k();
} }
else
{
FatalErrorInFunction
<< "Turbulence model not found in mesh database" << nl
<< "Database objects include: " << obr.sortedToc()
<< abort(FatalError);
return tmp<volScalarField>(nullptr); FatalErrorInFunction
} << "Turbulence model not found in mesh database" << nl
<< "Database objects include: " << obr.sortedToc()
<< abort(FatalError);
return tmp<volScalarField>();
} }

8
src/meshTools/coordinateSystems/coordinateRotation/EulerCoordinateRotation.C
View File

@ -70,7 +70,7 @@ Foam::tmp<Foam::vectorField> Foam::EulerCoordinateRotation::transform
) const ) const
{ {
NotImplemented; NotImplemented;
return tmp<vectorField>(nullptr); return tmp<vectorField>();
} }
@ -80,7 +80,7 @@ Foam::tmp<Foam::vectorField> Foam::EulerCoordinateRotation::invTransform
) const ) const
{ {
NotImplemented; NotImplemented;
return tmp<vectorField>(nullptr); return tmp<vectorField>();
} }
@ -97,7 +97,7 @@ Foam::tmp<Foam::tensorField> Foam::EulerCoordinateRotation::transformTensor
) const ) const
{ {
NotImplemented; NotImplemented;
return tmp<tensorField>(nullptr); return tmp<tensorField>();
} }
@ -117,7 +117,7 @@ Foam::tmp<Foam::tensorField> Foam::EulerCoordinateRotation::transformTensor
) const ) const
{ {
NotImplemented; NotImplemented;
return tmp<tensorField>(nullptr); return tmp<tensorField>();
} }

8
src/meshTools/coordinateSystems/coordinateRotation/STARCDCoordinateRotation.C
View File

@ -71,7 +71,7 @@ Foam::tmp<Foam::vectorField> Foam::STARCDCoordinateRotation::transform
) const ) const
{ {
NotImplemented; NotImplemented;
return tmp<vectorField>(nullptr); return tmp<vectorField>();
} }
@ -81,7 +81,7 @@ Foam::tmp<Foam::vectorField> Foam::STARCDCoordinateRotation::invTransform
) const ) const
{ {
NotImplemented; NotImplemented;
return tmp<vectorField>(nullptr); return tmp<vectorField>();
} }
@ -98,7 +98,7 @@ Foam::tmp<Foam::tensorField> Foam::STARCDCoordinateRotation::transformTensor
) const ) const
{ {
NotImplemented; NotImplemented;
return tmp<tensorField>(nullptr); return tmp<tensorField>();
} }
@ -118,7 +118,7 @@ Foam::tmp<Foam::tensorField> Foam::STARCDCoordinateRotation::transformTensor
) const ) const
{ {
NotImplemented; NotImplemented;
return tmp<tensorField>(nullptr); return tmp<tensorField>();
} }

4
src/meshTools/coordinateSystems/coordinateRotation/axesRotation.C
View File

@ -245,7 +245,7 @@ Foam::tmp<Foam::tensorField> Foam::axesRotation::transformTensor
) const ) const
{ {
NotImplemented; NotImplemented;
return tmp<tensorField>(nullptr); return tmp<tensorField>();
} }
@ -265,7 +265,7 @@ Foam::tmp<Foam::tensorField> Foam::axesRotation::transformTensor
) const ) const
{ {
NotImplemented; NotImplemented;
return tmp<tensorField>(nullptr); return tmp<tensorField>();
} }

10
src/sampling/sampledSurface/sampledSurface/sampledSurface.C
View File

@ -137,7 +137,7 @@ Foam::tmp<Foam::scalarField> Foam::sampledSurface::sample
) const ) const
{ {
NotImplemented; NotImplemented;
return tmp<scalarField>(nullptr); return tmp<scalarField>();
} }
@ -147,7 +147,7 @@ Foam::tmp<Foam::vectorField> Foam::sampledSurface::sample
) const ) const
{ {
NotImplemented; NotImplemented;
return tmp<vectorField>(nullptr); return tmp<vectorField>();
} }
@ -157,7 +157,7 @@ Foam::tmp<Foam::sphericalTensorField> Foam::sampledSurface::sample
) const ) const
{ {
NotImplemented; NotImplemented;
return tmp<sphericalTensorField>(nullptr); return tmp<sphericalTensorField>();
} }
@ -167,7 +167,7 @@ Foam::tmp<Foam::symmTensorField> Foam::sampledSurface::sample
) const ) const
{ {
NotImplemented; NotImplemented;
return tmp<symmTensorField>(nullptr); return tmp<symmTensorField>();
} }
@ -177,7 +177,7 @@ Foam::tmp<Foam::tensorField> Foam::sampledSurface::sample
) const ) const
{ {
NotImplemented; NotImplemented;
return tmp<tensorField>(nullptr); return tmp<tensorField>();
} }

2
src/thermophysicalModels/radiation/submodels/sootModel/noSoot/noSoot.C
View File

@ -66,7 +66,7 @@ void Foam::radiation::noSoot::correct()
const Foam::volScalarField& Foam::radiation::noSoot::soot() const const Foam::volScalarField& Foam::radiation::noSoot::soot() const
{ {
NotImplemented; NotImplemented;
return tmp<volScalarField>(nullptr); return tmp<volScalarField>();
} }
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

4
src/thermophysicalModels/solidChemistryModel/basicSolidChemistryModel/basicSolidChemistryModel.C
View File

@ -69,7 +69,7 @@ Foam::basicSolidChemistryModel::RR(const label i)
return dynamic_cast<volScalarField::Internal&> return dynamic_cast<volScalarField::Internal&>
( (
const_cast<volScalarField::Internal& > const_cast<volScalarField::Internal&>
( (
volScalarField::Internal::null() volScalarField::Internal::null()
) )
@ -88,7 +88,7 @@ Foam::basicSolidChemistryModel::calculateRR
return dynamic_cast<tmp<volScalarField::Internal>&> return dynamic_cast<tmp<volScalarField::Internal>&>
( (
const_cast<volScalarField::Internal& > const_cast<volScalarField::Internal&>
( (
volScalarField::Internal::null() volScalarField::Internal::null()
) )

4
src/waveModels/derivedFvPatchFields/waveAlpha/waveAlphaFvPatchScalarField.C
View File

@ -106,11 +106,11 @@ void Foam::waveAlphaFvPatchScalarField::updateCoeffs()
) )
); );
waveModel& model = const_cast<waveModel&>(tmodel()); waveModel& model = tmodel.constCast();
model.correct(db().time().value()); model.correct(db().time().value());
operator == (model.alpha()); operator==(model.alpha());
fixedValueFvPatchField<scalar>::updateCoeffs(); fixedValueFvPatchField<scalar>::updateCoeffs();
} }

4
src/waveModels/derivedFvPatchFields/waveVelocity/waveVelocityFvPatchVectorField.C
View File

@ -106,11 +106,11 @@ void Foam::waveVelocityFvPatchVectorField::updateCoeffs()
) )
); );
waveModel& model = const_cast<waveModel&>(tmodel()); waveModel& model = tmodel.constCast();
model.correct(db().time().value()); model.correct(db().time().value());
operator == (model.U()); operator==(model.U());
fixedValueFvPatchField<vector>::updateCoeffs(); fixedValueFvPatchField<vector>::updateCoeffs();
} }