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: minor de-clutter of List, DynamicList, DynamicField (#2385)

Browse Source 
- do not need contruct or move assign from SortableList.
  Rarely (never) used and can simply treat like a normal list
  by applying shrink beforehand.

- make append() methods return void instead of returning self, which
  makes it easier to derive from. Having them return self was a bit of
  an original design mistake.
  Chaining appends do not actually occur anywhere. Even if they were
  to be used, would not want to rely on them (fear of slicing on any
  derived classes).

BUG: IndirectList iterator comparison loses constness
This commit is contained in:
Mark Olesen
2022-03-07 10:46:25 +01:00
parent 47cd988296
commit 42fe95a6a9
11 changed files with 91 additions and 226 deletions
Download Patch File Download Diff File Expand all files Collapse all files

12
applications/test/IndirectList/Test-IndirectList.C
View File

@ -106,6 +106,18 @@ int main(int argc, char *argv[])
testFind(val, idl1); testFind(val, idl1);
} }
{
auto iter = idl1.cbegin();
const auto endIter = idl1.cend();
while (iter != endIter)
{
// No post-fix increment:
Info<< *iter << nl;
++iter;
}
}
inplaceReverseList(addresses); inplaceReverseList(addresses);
idl1.addressing() = std::move(addresses); idl1.addressing() = std::move(addresses);

9
src/OpenFOAM/containers/Bits/PackedList/PackedList.H
View File

@ -89,8 +89,8 @@ SourceFiles
\*---------------------------------------------------------------------------*/ \*---------------------------------------------------------------------------*/
#ifndef PackedList_H #ifndef Foam_PackedList_H
#define PackedList_H #define Foam_PackedList_H
#include "BitOps.H" #include "BitOps.H"
#include "labelList.H" #include "labelList.H"
@ -362,10 +362,9 @@ public:
//- Currently identical to resize. Subject to future change (Oct-2021) //- Currently identical to resize. Subject to future change (Oct-2021)
inline void resize_nocopy(const label numElem); inline void resize_nocopy(const label numElem);
//- Reserve allocation space for at least this size. //- Reserve allocation space for at least this size
//- (uses a size doubling strategy).
// Never shrinks the allocated size. // Never shrinks the allocated size.
// The list size is adjusted as per DynamicList with
// SizeInc=0, SizeMult=2, SizeDiv=1
inline void reserve(const label numElem); inline void reserve(const label numElem);
//- Clear the list, i.e. set addressable size to zero. //- Clear the list, i.e. set addressable size to zero.

62
src/OpenFOAM/containers/IndirectLists/IndirectListBase/IndirectListBase.H
View File

@ -6,7 +6,7 @@
\\/ M anipulation | \\/ M anipulation |
------------------------------------------------------------------------------- -------------------------------------------------------------------------------
Copyright (C) 2011-2016 OpenFOAM Foundation Copyright (C) 2011-2016 OpenFOAM Foundation
Copyright (C) 2017-2021 OpenCFD Ltd. Copyright (C) 2017-2022 OpenCFD Ltd.
------------------------------------------------------------------------------- -------------------------------------------------------------------------------
License License
This file is part of OpenFOAM. This file is part of OpenFOAM.
@ -39,8 +39,8 @@ SourceFiles
\*---------------------------------------------------------------------------*/ \*---------------------------------------------------------------------------*/
#ifndef IndirectListBase_H #ifndef Foam_IndirectListBase_H
#define IndirectListBase_H #define Foam_IndirectListBase_H
#include "List.H" #include "List.H"
@ -242,9 +242,11 @@ public:
// Iterators // Iterators
//- A non-const iterator for an indirect list //- A non-const iterator for an indirect list
// Only supports forward prefix increment, since the addressing
// may/may not support postfix or decrement.
class iterator class iterator
{ {
typename UList<T>::pointer data_; T* begin_;
typename addressing_type::const_iterator iter_; typename addressing_type::const_iterator iter_;
public: public:
@ -258,17 +260,14 @@ public:
iterator iterator
( (
UList<T>& list, UList<T>& list,
typename addressing_type::const_iterator baseIter typename addressing_type::const_iterator addrIter
) )
: :
data_(list.begin()), begin_(list.data()),
iter_(baseIter) iter_(addrIter)
{} {}
reference operator*() const reference operator*() const { return *(begin_ + *iter_); }
{
return data_[*iter_];
}
iterator& operator++() iterator& operator++()
{ {
@ -276,12 +275,12 @@ public:
return *this; return *this;
} }
bool operator==(iterator& rhs) const bool operator==(const iterator& rhs) const
{ {
return iter_ == rhs.iter_; return (iter_ == rhs.iter_);
} }
bool operator!=(iterator& rhs) const bool operator!=(const iterator& rhs) const
{ {
return (iter_ != rhs.iter_); return (iter_ != rhs.iter_);
} }
@ -289,9 +288,11 @@ public:
//- A const iterator for an indirect list //- A const iterator for an indirect list
// Only supports forward prefix increment, since the addressing
// may/may not support postfix or decrement.
class const_iterator class const_iterator
{ {
typename UList<T>::const_pointer data_; const T* begin_;
typename addressing_type::const_iterator iter_; typename addressing_type::const_iterator iter_;
public: public:
@ -305,17 +306,14 @@ public:
const_iterator const_iterator
( (
const UList<T>& list, const UList<T>& list,
typename addressing_type::const_iterator baseIter typename addressing_type::const_iterator addrIter
) )
: :
data_(list.begin()), begin_(list.cdata()),
iter_(baseIter) iter_(addrIter)
{} {}
reference operator*() const reference operator*() const { return *(begin_ + *iter_); }
{
return data_[*iter_];
}
const_iterator& operator++() const_iterator& operator++()
{ {
@ -323,14 +321,14 @@ public:
return *this; return *this;
} }
bool operator==(const_iterator& rhs) const bool operator==(const const_iterator& rhs) const
{ {
return iter_ == rhs.iter_; return (iter_ == rhs.iter_);
} }
bool operator!=(const_iterator& rhs) const bool operator!=(const const_iterator& rhs) const
{ {
return iter_ != rhs.iter_; return (iter_ != rhs.iter_);
} }
}; };
@ -364,17 +362,11 @@ public:
return const_iterator(values_, addr_.cend()); return const_iterator(values_, addr_.cend());
} }
//- Return a const_iterator at end of list //- Return a const_iterator at begin of list
inline const_iterator begin() const const_iterator begin() const { return cbegin(); }
{
return cbegin();
}
//- Return a const_iterator at end of list //- Return a const_iterator at end of list
inline const_iterator end() const const_iterator end() const { return cend(); }
{
return cend();
}
// Writing // Writing

45
src/OpenFOAM/containers/Lists/DynamicList/DynamicList.H
View File

@ -6,7 +6,7 @@
\\/ M anipulation | \\/ M anipulation |
------------------------------------------------------------------------------- -------------------------------------------------------------------------------
Copyright (C) 2011-2016 OpenFOAM Foundation Copyright (C) 2011-2016 OpenFOAM Foundation
Copyright (C) 2016-2021 OpenCFD Ltd. Copyright (C) 2016-2022 OpenCFD Ltd.
------------------------------------------------------------------------------- -------------------------------------------------------------------------------
License License
This file is part of OpenFOAM. This file is part of OpenFOAM.
@ -42,8 +42,8 @@ SourceFiles
\*---------------------------------------------------------------------------*/ \*---------------------------------------------------------------------------*/
#ifndef DynamicList_H #ifndef Foam_DynamicList_H
#define DynamicList_H #define Foam_DynamicList_H
#include "List.H" #include "List.H"
@ -154,9 +154,6 @@ public:
//- Move construct from List //- Move construct from List
inline DynamicList(List<T>&& lst); inline DynamicList(List<T>&& lst);
//- Move construct from SortableList
DynamicList(SortableList<T>&& lst);
//- Construct from Istream. Size set to size of list read. //- Construct from Istream. Size set to size of list read.
explicit DynamicList(Istream& is); explicit DynamicList(Istream& is);
@ -259,47 +256,32 @@ public:
template<int AnySizeMin> template<int AnySizeMin>
inline void transfer(DynamicList<T, AnySizeMin>& list); inline void transfer(DynamicList<T, AnySizeMin>& list);
//- Transfer contents of the argument SortableList into this. //- Copy append an element to the end of this list.
inline void transfer(SortableList<T>& list); inline void append(const T& val);
//- Append an element to the end of this list.
inline DynamicList<T, SizeMin>& append(const T& val);
//- Move append an element //- Move append an element
inline DynamicList<T, SizeMin>& append(T&& val); inline void append(T&& val);
//- Append another list to the end of this list. //- Append another list to the end of this list.
inline DynamicList<T, SizeMin>& append(const UList<T>& lst); inline void append(const UList<T>& lst);
//- Append a FixedList to the end of this list. //- Append a FixedList to the end of this list.
template<unsigned N> template<unsigned N>
inline DynamicList<T, SizeMin>& inline void append(const FixedList<T, N>& lst);
append(const FixedList<T, N>& lst);
//- Append an initializer list at the end of this list. //- Append an initializer list at the end of this list.
inline DynamicList<T, SizeMin>& inline void append(std::initializer_list<T> lst);
append(std::initializer_list<T> lst);
//- Append a IndirectList at the end of this list //- Append a IndirectList at the end of this list
template<class Addr> template<class Addr>
inline DynamicList<T, SizeMin>& inline void append(const IndirectListBase<T, Addr>& lst);
append(const IndirectListBase<T, Addr>& lst);
//- Move append list //- Move append list
inline DynamicList<T, SizeMin>& append(List<T>&& lst); inline void append(List<T>&& lst);
//- Move append list
inline DynamicList<T, SizeMin>&
append(DynamicList<T, SizeMin>&& lst);
//- Move append list //- Move append list
template<int AnySizeMin> template<int AnySizeMin>
inline DynamicList<T, SizeMin>& inline void append(DynamicList<T, AnySizeMin>&& list);
append(DynamicList<T, AnySizeMin>&& lst);
//- Move append list
inline DynamicList<T, SizeMin>&
append(SortableList<T>&& lst);
//- Append an element if not already in the list. //- Append an element if not already in the list.
// \return the change in list length // \return the change in list length
@ -377,9 +359,6 @@ public:
template<int AnySizeMin> template<int AnySizeMin>
inline void operator=(DynamicList<T, AnySizeMin>&& lst); inline void operator=(DynamicList<T, AnySizeMin>&& lst);
//- Move assignment
inline void operator=(SortableList<T>&& lst);
// Reading/writing // Reading/writing

90
src/OpenFOAM/containers/Lists/DynamicList/DynamicListI.H
View File

@ -6,7 +6,7 @@
\\/ M anipulation | \\/ M anipulation |
------------------------------------------------------------------------------- -------------------------------------------------------------------------------
Copyright (C) 2011-2016 OpenFOAM Foundation Copyright (C) 2011-2016 OpenFOAM Foundation
Copyright (C) 2016-2021 OpenCFD Ltd. Copyright (C) 2016-2022 OpenCFD Ltd.
------------------------------------------------------------------------------- -------------------------------------------------------------------------------
License License
This file is part of OpenFOAM. This file is part of OpenFOAM.
@ -493,21 +493,7 @@ Foam::DynamicList<T, SizeMin>::transfer
template<class T, int SizeMin> template<class T, int SizeMin>
inline void inline void Foam::DynamicList<T, SizeMin>::append
Foam::DynamicList<T, SizeMin>::transfer
(
SortableList<T>& list
)
{
list.shrink(); // Shrink away sort indices
capacity_ = list.size(); // Capacity after transfer == list size
List<T>::transfer(list);
}
template<class T, int SizeMin>
inline Foam::DynamicList<T, SizeMin>&
Foam::DynamicList<T, SizeMin>::append
( (
const T& val const T& val
) )
@ -516,13 +502,11 @@ Foam::DynamicList<T, SizeMin>::append
resize(idx + 1); resize(idx + 1);
this->operator[](idx) = val; // copy element this->operator[](idx) = val; // copy element
return *this;
} }
template<class T, int SizeMin> template<class T, int SizeMin>
inline Foam::DynamicList<T, SizeMin>& inline void Foam::DynamicList<T, SizeMin>::append
Foam::DynamicList<T, SizeMin>::append
( (
T&& val T&& val
) )
@ -531,13 +515,11 @@ Foam::DynamicList<T, SizeMin>::append
resize(idx + 1); resize(idx + 1);
this->operator[](idx) = std::move(val); // move assign element this->operator[](idx) = std::move(val); // move assign element
return *this;
} }
template<class T, int SizeMin> template<class T, int SizeMin>
inline Foam::DynamicList<T, SizeMin>& inline void Foam::DynamicList<T, SizeMin>::append
Foam::DynamicList<T, SizeMin>::append
( (
const UList<T>& lst const UList<T>& lst
) )
@ -556,14 +538,12 @@ Foam::DynamicList<T, SizeMin>::append
{ {
this->operator[](idx++) = val; // copy element this->operator[](idx++) = val; // copy element
} }
return *this;
} }
template<class T, int SizeMin> template<class T, int SizeMin>
template<unsigned N> template<unsigned N>
inline Foam::DynamicList<T, SizeMin>& inline void Foam::DynamicList<T, SizeMin>::append
Foam::DynamicList<T, SizeMin>::append
( (
const FixedList<T, N>& lst const FixedList<T, N>& lst
) )
@ -575,13 +555,11 @@ Foam::DynamicList<T, SizeMin>::append
{ {
this->operator[](idx++) = val; // copy element this->operator[](idx++) = val; // copy element
} }
return *this;
} }
template<class T, int SizeMin> template<class T, int SizeMin>
inline Foam::DynamicList<T, SizeMin>& inline void Foam::DynamicList<T, SizeMin>::append
Foam::DynamicList<T, SizeMin>::append
( (
std::initializer_list<T> lst std::initializer_list<T> lst
) )
@ -593,14 +571,12 @@ Foam::DynamicList<T, SizeMin>::append
{ {
this->operator[](idx++) = val; // copy element this->operator[](idx++) = val; // copy element
} }
return *this;
} }
template<class T, int SizeMin> template<class T, int SizeMin>
template<class Addr> template<class Addr>
inline Foam::DynamicList<T, SizeMin>& inline void Foam::DynamicList<T, SizeMin>::append
Foam::DynamicList<T, SizeMin>::append
( (
const IndirectListBase<T, Addr>& lst const IndirectListBase<T, Addr>& lst
) )
@ -614,13 +590,11 @@ Foam::DynamicList<T, SizeMin>::append
{ {
this->operator[](idx++) = lst[i]; // copy element this->operator[](idx++) = lst[i]; // copy element
} }
return *this;
} }
template<class T, int SizeMin> template<class T, int SizeMin>
inline Foam::DynamicList<T, SizeMin>& inline void Foam::DynamicList<T, SizeMin>::append
Foam::DynamicList<T, SizeMin>::append
( (
List<T>&& list List<T>&& list
) )
@ -641,47 +615,18 @@ Foam::DynamicList<T, SizeMin>::append
} }
list.clear(); list.clear();
return *this;
}
template<class T, int SizeMin>
inline Foam::DynamicList<T, SizeMin>&
Foam::DynamicList<T, SizeMin>::append
(
DynamicList<T, SizeMin>&& lst
)
{
append(std::move(static_cast<List<T>&>(lst)));
lst.clearStorage(); // Ensure capacity=0
return *this;
} }
template<class T, int SizeMin> template<class T, int SizeMin>
template<int AnySizeMin> template<int AnySizeMin>
inline Foam::DynamicList<T, SizeMin>& inline void Foam::DynamicList<T, SizeMin>::append
Foam::DynamicList<T, SizeMin>::append
( (
DynamicList<T, AnySizeMin>&& lst DynamicList<T, AnySizeMin>&& list
) )
{ {
append(std::move(static_cast<List<T>&>(lst))); append(std::move(static_cast<List<T>&>(list)));
lst.clearStorage(); // Ensure capacity=0 list.clearStorage(); // Ensure capacity=0
return *this;
}
template<class T, int SizeMin>
inline Foam::DynamicList<T, SizeMin>&
Foam::DynamicList<T, SizeMin>::append
(
SortableList<T>&& lst
)
{
lst.shrink(); // Shrink away sort indices
append(std::move(static_cast<List<T>&>(lst)));
return *this;
} }
@ -939,15 +884,4 @@ inline void Foam::DynamicList<T, SizeMin>::operator=
} }
template<class T, int SizeMin>
inline void Foam::DynamicList<T, SizeMin>::operator=
(
SortableList<T>&& lst
)
{
clear();
transfer(lst);
}
// ************************************************************************* // // ************************************************************************* //

27
src/OpenFOAM/containers/Lists/List/List.C
View File

@ -6,7 +6,7 @@
\\/ M anipulation | \\/ M anipulation |
------------------------------------------------------------------------------- -------------------------------------------------------------------------------
Copyright (C) 2011-2016 OpenFOAM Foundation Copyright (C) 2011-2016 OpenFOAM Foundation
Copyright (C) 2017-2021 OpenCFD Ltd. Copyright (C) 2017-2022 OpenCFD Ltd.
------------------------------------------------------------------------------- -------------------------------------------------------------------------------
License License
This file is part of OpenFOAM. This file is part of OpenFOAM.
@ -405,15 +405,6 @@ Foam::List<T>::List(DynamicList<T, SizeMin>&& list)
} }
template<class T>
Foam::List<T>::List(SortableList<T>&& list)
:
UList<T>()
{
transfer(list);
}
template<class T> template<class T>
Foam::List<T>::List(SLList<T>&& list) Foam::List<T>::List(SLList<T>&& list)
: :
@ -483,15 +474,6 @@ void Foam::List<T>::transfer(DynamicList<T, SizeMin>& list)
} }
template<class T>
void Foam::List<T>::transfer(SortableList<T>& list)
{
// Shrink away the sort indices
list.shrink();
transfer(static_cast<List<T>&>(list));
}
// * * * * * * * * * * * * * * * Member Operators * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * Member Operators * * * * * * * * * * * * * //
template<class T> template<class T>
@ -638,13 +620,6 @@ void Foam::List<T>::operator=(DynamicList<T, SizeMin>&& list)
} }
template<class T>
void Foam::List<T>::operator=(SortableList<T>&& list)
{
transfer(list);
}
template<class T> template<class T>
void Foam::List<T>::operator=(SLList<T>&& list) void Foam::List<T>::operator=(SLList<T>&& list)
{ {

17
src/OpenFOAM/containers/Lists/List/List.H
View File

@ -6,7 +6,7 @@
\\/ M anipulation | \\/ M anipulation |
------------------------------------------------------------------------------- -------------------------------------------------------------------------------
Copyright (C) 2011-2016 OpenFOAM Foundation Copyright (C) 2011-2016 OpenFOAM Foundation
Copyright (C) 2017-2021 OpenCFD Ltd. Copyright (C) 2017-2022 OpenCFD Ltd.
------------------------------------------------------------------------------- -------------------------------------------------------------------------------
License License
This file is part of OpenFOAM. This file is part of OpenFOAM.
@ -40,8 +40,8 @@ SourceFiles
\*---------------------------------------------------------------------------*/ \*---------------------------------------------------------------------------*/
#ifndef List_H #ifndef Foam_List_H
#define List_H #define Foam_List_H
#include "autoPtr.H" #include "autoPtr.H"
#include "UList.H" #include "UList.H"
@ -58,7 +58,6 @@ template<class T, unsigned N> class FixedList;
template<class T, int SizeMin> class DynamicList; template<class T, int SizeMin> class DynamicList;
template<class T> class PtrList; template<class T> class PtrList;
template<class T> class SortableList;
template<class T> Istream& operator>>(Istream& is, List<T>& list); template<class T> Istream& operator>>(Istream& is, List<T>& list);
@ -182,9 +181,6 @@ public:
template<int SizeMin> template<int SizeMin>
List(DynamicList<T, SizeMin>&& list); List(DynamicList<T, SizeMin>&& list);
//- Move construct from SortableList
List(SortableList<T>&& list);
//- Move construct from SLList //- Move construct from SLList
List(SLList<T>&& list); List(SLList<T>&& list);
@ -258,10 +254,6 @@ public:
template<int SizeMin> template<int SizeMin>
void transfer(DynamicList<T, SizeMin>& list); void transfer(DynamicList<T, SizeMin>& list);
//- Transfer the contents of the argument List into this list
//- and annul the argument list
void transfer(SortableList<T>& list);
//- Return subscript-checked element of UList and resizing the list //- Return subscript-checked element of UList and resizing the list
//- if required. //- if required.
inline T& newElmt(const label i); inline T& newElmt(const label i);
@ -302,9 +294,6 @@ public:
template<int SizeMin> template<int SizeMin>
void operator=(DynamicList<T, SizeMin>&& list); void operator=(DynamicList<T, SizeMin>&& list);
//- Move assignment. Takes constant time.
void operator=(SortableList<T>&& list);
//- Move assignment. Takes constant time //- Move assignment. Takes constant time
void operator=(SLList<T>&& list); void operator=(SLList<T>&& list);

4
src/OpenFOAM/containers/Lists/SortableList/SortableList.C
View File

@ -105,7 +105,7 @@ inline Foam::SortableList<T>::SortableList(std::initializer_list<T> values)
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
template<class T> template<class T>
void Foam::SortableList<T>::clear() inline void Foam::SortableList<T>::clear()
{ {
List<T>::clear(); List<T>::clear();
indices_.clear(); indices_.clear();
@ -113,7 +113,7 @@ void Foam::SortableList<T>::clear()
template<class T> template<class T>
Foam::List<T>& Foam::SortableList<T>::shrink() inline Foam::List<T>& Foam::SortableList<T>::shrink()
{ {
indices_.clear(); indices_.clear();
return static_cast<List<T>&>(*this); return static_cast<List<T>&>(*this);

24
src/OpenFOAM/containers/Lists/SortableList/SortableList.H
View File

@ -6,7 +6,7 @@
\\/ M anipulation | \\/ M anipulation |
------------------------------------------------------------------------------- -------------------------------------------------------------------------------
Copyright (C) 2011-2016 OpenFOAM Foundation Copyright (C) 2011-2016 OpenFOAM Foundation
Copyright (C) 2017-2021 OpenCFD Ltd. Copyright (C) 2017-2022 OpenCFD Ltd.
------------------------------------------------------------------------------- -------------------------------------------------------------------------------
License License
This file is part of OpenFOAM. This file is part of OpenFOAM.
@ -43,8 +43,8 @@ SourceFiles
\*---------------------------------------------------------------------------*/ \*---------------------------------------------------------------------------*/
#ifndef SortableList_H #ifndef Foam_SortableList_H
#define SortableList_H #define Foam_SortableList_H
#include "labelList.H" #include "labelList.H"
@ -106,22 +106,22 @@ public:
// Member Functions // Member Functions
//- Return the list of sorted indices. Updated every sort //- Return the list of sorted indices. Updated every sort
const labelList& indices() const const labelList& indices() const noexcept
{ {
return indices_; return indices_;
} }
//- Return non-const access to the sorted indices. Updated every sort //- Return non-const access to the sorted indices. Updated every sort
labelList& indices() labelList& indices() noexcept
{ {
return indices_; return indices_;
} }
//- Clear the list and the indices //- Clear the list and the indices
void clear(); inline void clear();
//- Clear the indices and return a reference to the underlying List //- Clear the indices and return a reference to the underlying List
List<T>& shrink(); inline List<T>& shrink();
//- Forward (stable) sort the list (if changed after construction). //- Forward (stable) sort the list (if changed after construction).
// Resizes the indices as required // Resizes the indices as required
@ -163,15 +163,7 @@ public:
}; };
// * * * * * * * * * * * * * * * Global Functions * * * * * * * * * * * * * // // Note: uses default Foam::Swap (move construct/assignment)
// Exchange contents of lists - see SortableList::swap().
template<class T>
inline void Swap(SortableList<T>& a, SortableList<T>& b)
{
a.swap(b);
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

13
src/OpenFOAM/fields/Fields/DynamicField/DynamicField.H
View File

@ -6,7 +6,7 @@
\\/ M anipulation | \\/ M anipulation |
------------------------------------------------------------------------------- -------------------------------------------------------------------------------
Copyright (C) 2011-2016 OpenFOAM Foundation Copyright (C) 2011-2016 OpenFOAM Foundation
Copyright (C) 2016-2021 OpenCFD Ltd. Copyright (C) 2016-2022 OpenCFD Ltd.
------------------------------------------------------------------------------- -------------------------------------------------------------------------------
License License
This file is part of OpenFOAM. This file is part of OpenFOAM.
@ -35,8 +35,8 @@ SourceFiles
\*---------------------------------------------------------------------------*/ \*---------------------------------------------------------------------------*/
#ifndef DynamicField_H #ifndef Foam_DynamicField_H
#define DynamicField_H #define Foam_DynamicField_H
#include "Field.H" #include "Field.H"
#include "DynamicList.H" #include "DynamicList.H"
@ -283,14 +283,13 @@ public:
inline void transfer(DynamicField<T, AnySizeMin>& list); inline void transfer(DynamicField<T, AnySizeMin>& list);
//- Append an element at the end of the list //- Append an element at the end of the list
inline DynamicField<T, SizeMin>& append(const T& val); inline void append(const T& val);
//- Move append an element //- Move append an element
inline DynamicField<T, SizeMin>& append(T&& val); inline void append(T&& val);
//- Append a List at the end of this list //- Append a List at the end of this list
inline DynamicField<T, SizeMin>& inline void append(const UList<T>& list);
append(const UList<T>& list);
//- Remove and return the top element //- Remove and return the top element
inline T remove(); inline T remove();

14
src/OpenFOAM/fields/Fields/DynamicField/DynamicFieldI.H
View File

@ -6,7 +6,7 @@
\\/ M anipulation | \\/ M anipulation |
------------------------------------------------------------------------------- -------------------------------------------------------------------------------
Copyright (C) 2011-2016 OpenFOAM Foundation Copyright (C) 2011-2016 OpenFOAM Foundation
Copyright (C) 2016-2021 OpenCFD Ltd. Copyright (C) 2016-2022 OpenCFD Ltd.
------------------------------------------------------------------------------- -------------------------------------------------------------------------------
License License
This file is part of OpenFOAM. This file is part of OpenFOAM.
@ -582,8 +582,7 @@ inline void Foam::DynamicField<T, SizeMin>::transfer
template<class T, int SizeMin> template<class T, int SizeMin>
inline Foam::DynamicField<T, SizeMin>& inline void Foam::DynamicField<T, SizeMin>::append
Foam::DynamicField<T, SizeMin>::append
( (
const T& val const T& val
) )
@ -592,13 +591,11 @@ Foam::DynamicField<T, SizeMin>::append
resize(idx + 1); resize(idx + 1);
this->operator[](idx) = val; // copy element this->operator[](idx) = val; // copy element
return *this;
} }
template<class T, int SizeMin> template<class T, int SizeMin>
inline Foam::DynamicField<T, SizeMin>& inline void Foam::DynamicField<T, SizeMin>::append
Foam::DynamicField<T, SizeMin>::append
( (
T&& val T&& val
) )
@ -607,13 +604,11 @@ Foam::DynamicField<T, SizeMin>::append
resize(idx + 1); resize(idx + 1);
this->operator[](idx) = std::move(val); // move assign element this->operator[](idx) = std::move(val); // move assign element
return *this;
} }
template<class T, int SizeMin> template<class T, int SizeMin>
inline Foam::DynamicField<T, SizeMin>& inline void Foam::DynamicField<T, SizeMin>::append
Foam::DynamicField<T, SizeMin>::append
( (
const UList<T>& list const UList<T>& list
) )
@ -632,7 +627,6 @@ Foam::DynamicField<T, SizeMin>::append
{ {
this->operator[](idx++) = val; // copy element this->operator[](idx++) = val; // copy element
} }
return *this;
} }