Commit 22c695f4 authored by Mark Olesen's avatar Mark Olesen
Browse files

Merge branch 'feature-ptrlist' into 'develop'

Updated/modified PtrList implementation

See merge request !193
parents 2e0e4de2 2e85c285
......@@ -29,7 +29,7 @@ Description
#include "scalar.H"
#include "IOstreams.H"
#include "PtrList.H"
#include "PtrDynList.H"
#include "DLPtrList.H"
#include "SLPtrList.H"
#include "plane.H"
......@@ -58,6 +58,16 @@ public:
Info<<"delete Scalar: " << data_ << endl;
}
const scalar& value() const
{
return data_;
}
scalar& value()
{
return data_;
}
autoPtr<Scalar> clone() const
{
return autoPtr<Scalar>::New(data_);
......@@ -71,6 +81,151 @@ public:
};
// As per
//
// template<class T>
// Ostream& operator<<(Ostream& os, const UPtrList<T>& list)
//
// but handle nullptr
template<class T>
Ostream& printAddr
(
Ostream& os,
const UPtrList<T>& list
)
{
const label len = list.size();
// Size and start delimiter
os << nl << indent << len << nl
<< indent << token::BEGIN_LIST << incrIndent << nl;
for (label i=0; i < len; ++i)
{
os << "addr=" << long(list(i)) << nl;
}
// End delimiter
os << decrIndent << indent << token::END_LIST << nl;
return os;
}
// As per
//
// template<class T>
// Ostream& operator<<(Ostream& os, const UPtrList<T>& list)
//
// but handle nullptr
template<class T>
Ostream& print
(
Ostream& os,
const UPtrList<T>& list,
const bool debug=false
)
{
const label len = list.size();
// Size and start delimiter
os << nl << indent << len << nl
<< indent << token::BEGIN_LIST << incrIndent << nl;
for (label i=0; i < len; ++i)
{
const T* ptr = list(i);
if (ptr)
{
os << *ptr << nl;
}
else
{
os << "nullptr" << nl;
}
}
// End delimiter
os << decrIndent << indent << token::END_LIST << nl;
return os;
}
template<class T, int SizeMin>
Ostream& print
(
Ostream& os,
const PtrDynList<T, SizeMin>& list,
const bool debug=false
)
{
const label len = list.size();
// Size and start delimiter
os << nl << indent << len << nl
<< indent << token::BEGIN_LIST << incrIndent << nl;
for (label i=0; i < len; ++i)
{
const T* ptr = list(i);
if (ptr)
{
os << *ptr << nl;
}
else
{
os << "nullptr" << nl;
}
}
if (debug)
{
const label cap = list.capacity();
for (label i=len; i < cap; ++i)
{
const T* ptr = list(i);
os << "unused " << long(ptr) << nl;
}
}
// End delimiter
os << decrIndent << indent << token::END_LIST << nl;
return os;
}
template<class T>
Ostream& report
(
Ostream& os,
const UPtrList<T>& list,
const bool debug=false
)
{
return print(os, list, debug);
}
template<class T, int SizeMin>
Ostream& report
(
Ostream& os,
const PtrDynList<T,SizeMin>& list,
const bool debug=false
)
{
os << "capacity=" << list.capacity() << nl;
return print(os, list, debug);
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
// Main program:
......@@ -110,6 +265,23 @@ int main(int argc, char *argv[])
}
}
// Same but as SLPtrList
{
SLPtrList<Scalar> llist1;
llist1.insert(new Scalar(100));
llist1.insert(new Scalar(200));
llist1.insert(new Scalar(300));
for (const auto& it : llist1)
{
Info<< typeid(it).name() << nl
<< "for-: " << it << endl;
}
PtrList<Scalar> list1b(llist1);
Info<< list1b << endl;
}
forAll(list1, i)
{
list1.set(i, new Scalar(1.3*i));
......@@ -133,7 +305,7 @@ int main(int argc, char *argv[])
Info<<"indirectly delete some items via set(.., 0) :" << endl;
for (label i = 0; i < 3; i++)
{
list1.set(i, 0);
list1.set(i, nullptr);
}
Info<<"transfer list2 -> list1:" << endl;
......@@ -147,6 +319,36 @@ int main(int argc, char *argv[])
Info<<"list1: " << list1 << endl;
{
PtrList<Scalar> list1a(list1, false);
Info<<"Clone constructed" << endl;
Info<<"in: " << list1 << nl
<<"out: " << list1a << nl
<<"addresses:" << nl;
printAddr(Info, list1);
printAddr(Info, list1a);
PtrList<Scalar> list1b(list1a, true);
Info<<"Reuse constructed" << endl;
Info<<"in: " << list1a << nl
<<"out: " << list1b << nl
<<"addresses:" << nl;
printAddr(Info, list1a);
printAddr(Info, list1b);
PtrList<Scalar> list1c(list1b.clone());
Info<<"Explicit clone()" << endl;
Info<<"in: " << list1b << nl
<<"out: " << list1c << nl
<<"addresses:" << nl;
printAddr(Info, list1b);
printAddr(Info, list1c);
}
PtrList<Scalar> list3(std::move(list1));
Info<<"Move constructed" << endl;
......@@ -174,6 +376,26 @@ int main(int argc, char *argv[])
UPtrList<Scalar> ulist1(list3);
Info<<"ulist1: " << ulist1 << nl;
Info<<"PtrList addresses:";
printAddr(Info, list3);
Info<<"UPtrList addresses:";
printAddr(Info, ulist1);
Info<< nl;
{
Info<<"UPtrList(const UPtrList&)" << nl;
const UPtrList<Scalar>& cref = ulist1;
UPtrList<Scalar> ulist1cp(cref);
Info<<"src addresses:";
printAddr(Info, cref);
Info<<"dst addresses:";
printAddr(Info, ulist1cp);
Info<< nl;
}
Info<<"Move construct:" << endl;
......@@ -204,6 +426,10 @@ int main(int argc, char *argv[])
Info<< "iter[2]=" << iter1[2] << nl;
Info<< "iter1 < iter2 : " << (iter1 < iter2) << nl;
Info<< "iter1 >= iter2 : " << (iter1 >= iter2) << nl;
Info<<"->" << iter1->value() << nl;
Info<<"*" << (*iter1).value() << nl;
Info<<"()" << iter1().value() << nl;
}
PtrList<plane> planes;
......@@ -216,6 +442,46 @@ int main(int argc, char *argv[])
Info<< " plane " << p << endl;
}
Info<<"Testing PtrDynList" << nl;
PtrDynList<plane> dynPlanes;
{
dynPlanes.append(new plane(vector::one, vector::one));
dynPlanes.append(new plane(vector(1,2,3), vector::one));
dynPlanes.append(nullptr);
dynPlanes.set(6, new plane(vector(2,2,1), vector::one));
dynPlanes.set(10, new plane(vector(4,5,6), vector::one));
}
Info<< nl << "PtrList: ";
report(Info, dynPlanes, true);
dynPlanes.resize(9);
Info<< nl << "resize()";
report(Info, dynPlanes, true);
dynPlanes.clear();
Info<<"clear()" << nl;
report(Info, dynPlanes);
Info<<"now append again" << endl;
{
dynPlanes.append(new plane(vector::one, vector::one));
dynPlanes.append(new plane(vector(1,2,3), vector::one));
dynPlanes.set(5, new plane(vector(2,2,1), vector::one));
}
report(Info, dynPlanes, true);
Info<<"free()" << endl;
dynPlanes.free();
report(Info, dynPlanes, true);
Info<< nl << "Done." << endl;
return 0;
}
......
......@@ -57,8 +57,6 @@ using namespace Foam;
#include "emptyPolyPatch.H"
#include "preservePatchTypes.H"
#include "cellShape.H"
#include "SLList.H"
#include "SLPtrList.H"
label nPoints = 0;
label nCells = 0;
......
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2018 OpenCFD Ltd.
\\/ 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::PtrDynList
Description
A dynamically resizable PtrList with allocation management.
See Also
Foam::UPtrList
Foam::PtrList
SourceFiles
PtrDynListI.H
\*---------------------------------------------------------------------------*/
#ifndef PtrDynList_H
#define PtrDynList_H
#include "PtrList.H"
#include <type_traits>
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
// Forward declarations
template<class T, int SizeMin> class PtrDynList;
/*---------------------------------------------------------------------------*\
Class PtrDynList Declaration
\*---------------------------------------------------------------------------*/
template<class T, int SizeMin=64>
class PtrDynList
:
public PtrList<T>
{
static_assert(SizeMin > 0, "Invalid min size parameter");
// Private data
//- The capacity (allocated size) of the list.
label capacity_;
public:
// Constructors
//- Construct null
inline constexpr PtrDynList() noexcept;
//- Construct with given capacity.
explicit inline PtrDynList(const label len);
//- Copy construct using 'clone()' method on each element
inline PtrDynList(const PtrDynList<T, SizeMin>& list);
//- Move construct
inline PtrDynList(PtrDynList<T, SizeMin>&& list);
//- Destructor
~PtrDynList() = default;
// Member Functions
// Access
//- Size of the underlying storage.
inline label capacity() const;
// Edit
//- Delete the allocated entries, but retain the list size.
using PtrList<T>::free;
//- Alter the size of the underlying storage.
inline void setCapacity(const label nElem);
//- Alter the addressed list size.
inline void resize(const label newLen);
//- Alter the addressed list size.
inline void setSize(const label newLen);
//- Reserve allocation space for at least this size.
// Never shrinks the allocated size, use setCapacity() for that.
inline void reserve(const label nElem);
//- Clear the addressed list, i.e. set the size to zero.
// Allocated size does not change
inline void clear();
//- Clear the list and delete storage.
inline void clearStorage();
//- Expand the addressable size to fit the allocated capacity.
// Returns the previous addressable size.
inline label expandStorage();
//- Shrink the allocated space to the number of elements used.
inline void shrink();
//- Append an element to the end of the list
inline void append(T* ptr);
//- Append an element to the end of the list
inline void append(const autoPtr<T>& aptr);
//- Append an element to the end of the list
inline void append(const tmp<T>& tptr);
//- Remove and return the top element
inline autoPtr<T> remove();
//- Return true if element is set (ie, not a nullptr)
inline bool set(const label i) const;
//- Set element to given pointer and return old element (can be null)
inline autoPtr<T> set(const label i, T* ptr);
//- Set element to given autoPtr and return old element
inline autoPtr<T> set(const label i, const autoPtr<T>& aptr);
//- Set element to given tmp and return old element
inline autoPtr<T> set(const label i, const tmp<T>& tptr);
//- Reorder elements. Reordering must be unique (ie, shuffle).
inline void reorder(const labelUList& oldToNew);
// Member Operators
//- Copy (clone) assignment
inline void operator=(const PtrList<T>& list);
//- Copy (clone) assignment
inline void operator=(const PtrDynList<T, SizeMin>& list);
//- Copy (clone) assignment with different sizing parameters
template<int AnySizeMin>
inline void operator=(const PtrDynList<T, AnySizeMin>& list);
//- Move assignment
inline void operator=(PtrList<T>&& list);
//- Move assignment
inline void operator=(PtrDynList<T, SizeMin>&& list);
//- Move assignment with different sizing parameters
template<int AnySizeMin>
inline void operator=(PtrDynList<T, AnySizeMin>&& list);
};
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#include "PtrDynListI.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2018 OpenCFD Ltd.
\\/ 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 "autoPtr.H"
#include "tmp.H"
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
template<class T, int SizeMin>
inline constexpr Foam::PtrDynList<T, SizeMin>::PtrDynList() noexcept
:
PtrList<T>(),
capacity_(0)
{}
template<class T, int SizeMin>
inline Foam::PtrDynList<T, SizeMin>::PtrDynList(const label len)
:
PtrList<T>(len),
capacity_(len)
{
PtrList<T>::size(0);
}
template<class T, int SizeMin>
inline Foam::PtrDynList<T, SizeMin>::PtrDynList
(
const PtrDynList<T, SizeMin>& list
)
:
PtrList<T>(list),
capacity_(PtrList<T>::size())
{}
template<class T, int SizeMin>
inline Foam::PtrDynList<T, SizeMin>::PtrDynList
(
PtrDynList<T, SizeMin>&& list
)
:
PtrList<T>(std::move(list)),
capacity_(list.capacity_)
{
list.clearStorage();
}
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
template<class T, int SizeMin>