PtrListDictionary: New form of Dictionary in which the list type is PtrList rather than a linked-list

src/OpenFOAM/containers/Dictionaries/DictionaryBase/DictionaryBase.H

@@ -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();

src/OpenFOAM/containers/Dictionaries/PtrDictionary/PtrDictionary.H

@@ -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

src/OpenFOAM/containers/Dictionaries/PtrListDictionary/PtrListDictionary.C

@@ -0,0 +1,127 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  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);
+}
+
+
+// ************************************************************************* //

src/OpenFOAM/containers/Dictionaries/PtrListDictionary/PtrListDictionary.H

@@ -0,0 +1,121 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  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
+
+// ************************************************************************* //