Commit 7b5d6114 authored by Henry Weller's avatar Henry Weller
Browse files

PtrListDictionary: New form of Dictionary in which the list type is PtrList...

PtrListDictionary: New form of Dictionary in which the list type is PtrList rather than a linked-list
parent 15c7b16c
Test-PtrListDictionary.C
EXE = $(FOAM_USER_APPBIN)/Test-PtrListDictionary
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2015 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/>.
Application
Description
\*---------------------------------------------------------------------------*/
#include "OSspecific.H"
#include "scalar.H"
#include "IOstreams.H"
#include "PtrListDictionary.H"
using namespace Foam;
class Scalar
{
scalar data_;
public:
Scalar()
:
data_(0)
{}
Scalar(scalar val)
:
data_(val)
{}
~Scalar()
{
Info<<"delete Scalar: " << data_ << endl;
}
friend Ostream& operator<<(Ostream& os, const Scalar& val)
{
os << val.data_;
return os;
}
};
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
// Main program:
int main(int argc, char *argv[])
{
PtrListDictionary<Scalar> scalarDict(10);
forAll(scalarDict, i)
{
word key("ent" + name(i));
scalarDict.set(i, key, new Scalar(1.3*i));
}
Info<< nl << "scalarDict1: " << endl;
forAll(scalarDict, i)
{
Info<< "elem " << i << " = " << scalarDict[i] << endl;
}
Scalar* ent8Ptr = scalarDict.lookupPtr("ent8");
Info<< "ent8 = " << *ent8Ptr << endl;
PtrListDictionary<Scalar> scalarDict2(15);
forAll(scalarDict2, i)
{
word key("ent" + name(i));
scalarDict2.set(i, key, new Scalar(1.3*i));
}
Info<< nl << "scalarDict2: " << endl;
forAll(scalarDict2, i)
{
Info<< "elem " << i << " = " << scalarDict2[i] << endl;
}
scalarDict.transfer(scalarDict2);
Scalar* p = scalarDict.lookupPtr("ent8");
if (p)
{
Info<< "found: " << *p << endl;
}
else
{
Info<< "no p: " << endl;
}
scalarDict.clear();
Info<< nl << "Done." << endl;
return 0;
}
// ************************************************************************* //
......@@ -74,13 +74,15 @@ class DictionaryBase
:
public IDLListType
{
// Private data
protected:
// Protected data
//- HashTable of the entries held on the IDLListType for quick lookup
HashTable<T*> hashedTs_;
// Private Member functions
// Protected Member functions
// Add the IDLListType entries into the HashTable
void addEntries();
......
......@@ -25,11 +25,10 @@ Class
Foam::PtrDictionary
Description
Template dictionary class which does not manages the storage
associated with it.
Template dictionary class which manages the storage associated with it.
It is derived from DictionaryBase instantiated on a non-memory managed
form of intrusive doubly-linked list of T.
It is derived from DictionaryBase instantiated on a memory managed form of
intrusive doubly-linked list of \<T\>.
SourceFiles
PtrDictionary.C
......
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2015 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/>.
\*---------------------------------------------------------------------------*/
#include "PtrListDictionary.H"
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
template<class T>
Foam::PtrListDictionary<T>::PtrListDictionary(const label size)
:
DictionaryBase<PtrList<T>, T>(2*size)
{
PtrList<T>::setSize(size);
}
template<class T>
Foam::PtrListDictionary<T>::PtrListDictionary(const PtrListDictionary& dict)
:
DictionaryBase<PtrList<T>, T>(dict)
{}
template<class T>
template<class INew>
Foam::PtrListDictionary<T>::PtrListDictionary(Istream& is, const INew& iNew)
:
DictionaryBase<PtrList<T>, T>(is, iNew)
{}
template<class T>
Foam::PtrListDictionary<T>::PtrListDictionary(Istream& is)
:
DictionaryBase<PtrList<T>, T>(is)
{}
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
template<class T>
inline Foam::autoPtr<T> Foam::PtrListDictionary<T>::set
(
const label i,
const word& key,
T* ptr
)
{
if (!DictionaryBase<PtrList<T>, T>::hashedTs_.insert(key, ptr))
{
FatalErrorIn
(
"PtrListDictionary<T>::set(const label i, const word& key, T* ptr)"
) << "Cannot insert with key '" << key << "' into hash-table"
<< abort(FatalError);
}
return PtrList<T>::set(i, ptr);
}
template<class T>
inline Foam::autoPtr<T> Foam::PtrListDictionary<T>::set
(
const label i,
const word& key,
autoPtr<T>& aptr
)
{
T* ptr = aptr.ptr();
if (!DictionaryBase<PtrList<T>, T>::hashedTs_.insert(key, ptr))
{
FatalErrorIn
(
"PtrListDictionary<T>::"
"set(const label i, const word& key, autoPtr<T>& aptr)"
) << "Cannot insert with key '" << key << "' into hash-table"
<< abort(FatalError);
}
return PtrList<T>::set(i, ptr);
}
template<class T>
inline Foam::autoPtr<T> Foam::PtrListDictionary<T>::set
(
const label i,
const word& key,
tmp<T>& t
)
{
T* ptr = t.ptr();
if (!DictionaryBase<PtrList<T>, T>::hashedTs_.insert(key, ptr))
{
FatalErrorIn
(
"PtrListDictionary<T>::"
"set(const label i, const word& key, tmp<T>& t)"
) << "Cannot insert with key '" << key << "' into hash-table"
<< abort(FatalError);
}
return PtrList<T>::set(i, ptr);
}
// ************************************************************************* //
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2015 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::PtrListDictionary
Description
Template dictionary class which manages the storage associated with it.
It is derived from DictionaryBase instantiated on the memory managed PtrList
of \<T\> to provide ordered indexing in addition to the dictionary lookup.
SourceFiles
PtrListDictionary.C
\*---------------------------------------------------------------------------*/
#ifndef PtrListDictionary_H
#define PtrListDictionary_H
#include "DictionaryBase.H"
#include "PtrList.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
/*---------------------------------------------------------------------------*\
Class PtrListDictionary Declaration
\*---------------------------------------------------------------------------*/
template<class T>
class PtrListDictionary
:
public DictionaryBase<PtrList<T>, T>
{
public:
// Constructors
//- Construct given initial list size
PtrListDictionary(const label size);
//- Copy construct
PtrListDictionary(const PtrListDictionary&);
//- Construct from Istream using given Istream constructor class
template<class INew>
PtrListDictionary(Istream&, const INew&);
//- Construct from Istream
PtrListDictionary(Istream&);
// Member functions
//- Set element to pointer provided and return old element
autoPtr<T> set(const label, const word& key, T*);
//- Set element to autoPtr value provided and return old element
autoPtr<T> set(const label, const word& key, autoPtr<T>&);
//- Set element to tmp value provided and return old element
autoPtr<T> set(const label, const word& key, tmp<T>&);
// Member operators
using PtrList<T>::operator[];
//- Find and return entry
const T& operator[](const word& key) const
{
return *DictionaryBase<PtrList<T>, T>::operator[](key);
}
//- Find and return entry
T& operator[](const word& key)
{
return *DictionaryBase<PtrList<T>, T>::operator[](key);
}
};
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#ifdef NoRepository
# include "PtrListDictionary.C"
#endif
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //
Markdown is supported
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment