From 55a89e9db3d78dca419db5f10256b60a1306d076 Mon Sep 17 00:00:00 2001
From: Mark Olesen <Mark.Olesen@Germany>
Date: Fri, 30 Oct 2009 18:31:28 +0100
Subject: [PATCH] added HashTbl as development replacement for HashTable

- rename to HashTable later when it is considered stable
---
 applications/test/HashTable3/Make/files       |   3 +
 applications/test/HashTable3/Make/options     |   2 +
 applications/test/HashTable3/hashTableTest3.C |  83 +++
 src/OpenFOAM/Make/files                       |   1 +
 .../containers/HashTables/HashTbl/HashTbl.C   | 665 ++++++++++++++++++
 .../containers/HashTables/HashTbl/HashTbl.H   | 466 ++++++++++++
 .../containers/HashTables/HashTbl/HashTblI.H  | 548 +++++++++++++++
 .../containers/HashTables/HashTbl/HashTblIO.C | 246 +++++++
 .../HashTables/HashTbl/HashTblName.C          |  33 +
 9 files changed, 2047 insertions(+)
 create mode 100644 applications/test/HashTable3/Make/files
 create mode 100644 applications/test/HashTable3/Make/options
 create mode 100644 applications/test/HashTable3/hashTableTest3.C
 create mode 100644 src/OpenFOAM/containers/HashTables/HashTbl/HashTbl.C
 create mode 100644 src/OpenFOAM/containers/HashTables/HashTbl/HashTbl.H
 create mode 100644 src/OpenFOAM/containers/HashTables/HashTbl/HashTblI.H
 create mode 100644 src/OpenFOAM/containers/HashTables/HashTbl/HashTblIO.C
 create mode 100644 src/OpenFOAM/containers/HashTables/HashTbl/HashTblName.C

diff --git a/applications/test/HashTable3/Make/files b/applications/test/HashTable3/Make/files
new file mode 100644
index 0000000000..e8ec193ffa
--- /dev/null
+++ b/applications/test/HashTable3/Make/files
@@ -0,0 +1,3 @@
+hashTableTest3.C
+
+EXE = $(FOAM_USER_APPBIN)/hashTableTest3
diff --git a/applications/test/HashTable3/Make/options b/applications/test/HashTable3/Make/options
new file mode 100644
index 0000000000..6a9e9810b3
--- /dev/null
+++ b/applications/test/HashTable3/Make/options
@@ -0,0 +1,2 @@
+/* EXE_INC = -I$(LIB_SRC)/cfdTools/include */
+/* EXE_LIBS = -lfiniteVolume */
diff --git a/applications/test/HashTable3/hashTableTest3.C b/applications/test/HashTable3/hashTableTest3.C
new file mode 100644
index 0000000000..422e35696c
--- /dev/null
+++ b/applications/test/HashTable3/hashTableTest3.C
@@ -0,0 +1,83 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2009-2009 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 2 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, write to the Free Software Foundation,
+    Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+
+Description
+
+    Test speeds for some HashTable operations
+
+\*---------------------------------------------------------------------------*/
+
+#include "argList.H"
+#include "HashTable.H"
+#include "HashPtrTable.H"
+#include "Map.H"
+#include "StaticHashTable.H"
+#include "HashTbl.H"
+#include "cpuTime.H"
+
+using namespace Foam;
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+// Main program:
+
+int main(int argc, char *argv[])
+{
+    const label nLoops = 30;
+    const label nBase  = 100000;
+    const label nSize  = nLoops * nBase;
+
+    cpuTime timer;
+
+    // ie, a
+    // Map<label> map(2 * nSize);
+    // HashTable<label, label, Hash<label> > map(2 * nSize);
+    // StaticHashTable<label, label, Hash<label> > map(2 * nSize);
+    HashTbl<label, label, Hash<label> > map(2 * nSize);
+
+    Info<< "Constructed map of size: " << nSize
+        << "  " << timer.cpuTimeIncrement() << " s\n\n";
+
+    for (label i = 0; i < nSize; i++)
+    {
+        map.insert(i, i);
+    }
+    Info<< "Inserted " << nSize << " elements: "
+        << timer.cpuTimeIncrement() << " s\n\n";
+
+
+    label elemI = 0;
+    for (label iLoop = 0; iLoop < nLoops; iLoop++)
+    {
+        for (label i = 0; i < nBase; i++)
+        {
+            map.erase(elemI++);
+        }
+        Info<< "loop " << iLoop << " - Erased " << nBase << " elements: "
+            << "  " << timer.cpuTimeIncrement() << " s\n";
+    }
+
+    return 0;
+}
+
+// ************************************************************************* //
diff --git a/src/OpenFOAM/Make/files b/src/OpenFOAM/Make/files
index 2823c2a9ec..a290ec2847 100644
--- a/src/OpenFOAM/Make/files
+++ b/src/OpenFOAM/Make/files
@@ -61,6 +61,7 @@ $(sha1)/SHA1Digest.C
 
 primitives/random/Random.C
 
+containers/HashTables/HashTbl/HashTblName.C
 containers/HashTables/HashTable/HashTableName.C
 containers/HashTables/StaticHashTable/StaticHashTableName.C
 containers/Lists/SortableList/ParSortableListName.C
diff --git a/src/OpenFOAM/containers/HashTables/HashTbl/HashTbl.C b/src/OpenFOAM/containers/HashTables/HashTbl/HashTbl.C
new file mode 100644
index 0000000000..8e7be6b147
--- /dev/null
+++ b/src/OpenFOAM/containers/HashTables/HashTbl/HashTbl.C
@@ -0,0 +1,665 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 1991-2009 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 2 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, write to the Free Software Foundation,
+    Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef HashTbl_C
+#define HashTbl_C
+
+#include "HashTbl.H"
+#include "List.H"
+
+// * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * * //
+
+template<class T, class Key, class Hash>
+Foam::label Foam::HashTbl<T, Key, Hash>::canonicalSize(const label size)
+{
+    if (size < 1)
+    {
+        return 0;
+    }
+
+    // enforce power of two
+    unsigned int goodSize = size;
+
+    if (goodSize & (goodSize - 1))
+    {
+        // brute-force is fast enough
+        goodSize = 1;
+        while (goodSize < unsigned(size))
+        {
+            goodSize <<= 1;
+        }
+    }
+
+    return goodSize;
+}
+
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+template<class T, class Key, class Hash>
+Foam::HashTbl<T, Key, Hash>::HashTbl(const label size)
+:
+    HashTblName(),
+    nElmts_(0),
+    tableSize_(canonicalSize(size)),
+    table_(NULL),
+    endIter_(*this, NULL, 0),
+    endConstIter_(*this, NULL, 0)
+{
+    if (tableSize_)
+    {
+        table_ = new hashedEntry*[tableSize_];
+
+        for (label hashIdx = 0; hashIdx < tableSize_; hashIdx++)
+        {
+            table_[hashIdx] = 0;
+        }
+    }
+}
+
+
+template<class T, class Key, class Hash>
+Foam::HashTbl<T, Key, Hash>::HashTbl(const HashTbl<T, Key, Hash>& ht)
+:
+    HashTblName(),
+    nElmts_(0),
+    tableSize_(ht.tableSize_),
+    table_(NULL),
+    endIter_(*this, NULL, 0),
+    endConstIter_(*this, NULL, 0)
+{
+    if (tableSize_)
+    {
+        table_ = new hashedEntry*[tableSize_];
+
+        for (label hashIdx = 0; hashIdx < tableSize_; hashIdx++)
+        {
+            table_[hashIdx] = 0;
+        }
+
+        for (const_iterator iter = ht.cbegin(); iter != ht.cend(); ++iter)
+        {
+            insert(iter.key(), *iter);
+        }
+    }
+}
+
+template<class T, class Key, class Hash>
+Foam::HashTbl<T, Key, Hash>::HashTbl
+(
+    const Xfer<HashTbl<T, Key, Hash> >& ht
+)
+:
+    HashTblName(),
+    nElmts_(0),
+    tableSize_(0),
+    table_(NULL),
+    endIter_(*this, NULL, 0),
+    endConstIter_(*this, NULL, 0)
+{
+    transfer(ht());
+}
+
+
+// * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
+
+template<class T, class Key, class Hash>
+Foam::HashTbl<T, Key, Hash>::~HashTbl()
+{
+    if (table_)
+    {
+        clear();
+        delete[] table_;
+    }
+}
+
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+template<class T, class Key, class Hash>
+bool Foam::HashTbl<T, Key, Hash>::found(const Key& key) const
+{
+    if (nElmts_)
+    {
+        const label hashIdx = hashKeyIndex(key);
+
+        for (hashedEntry* ep = table_[hashIdx]; ep; ep = ep->next_)
+        {
+            if (key == ep->key_)
+            {
+                return true;
+            }
+        }
+    }
+
+#   ifdef FULLDEBUG
+    if (debug)
+    {
+        Info<< "HashTbl<T, Key, Hash>::found(const Key& key) : "
+            << "Entry " << key << " not found in hash table\n";
+    }
+#   endif
+
+    return false;
+}
+
+
+template<class T, class Key, class Hash>
+typename Foam::HashTbl<T, Key, Hash>::iterator
+Foam::HashTbl<T, Key, Hash>::find
+(
+    const Key& key
+)
+{
+    if (nElmts_)
+    {
+        const label hashIdx = hashKeyIndex(key);
+
+        for (hashedEntry* ep = table_[hashIdx]; ep; ep = ep->next_)
+        {
+            if (key == ep->key_)
+            {
+                return iterator(*this, ep, hashIdx);
+            }
+        }
+    }
+
+#   ifdef FULLDEBUG
+    if (debug)
+    {
+        Info<< "HashTbl<T, Key, Hash>::find(const Key& key) : "
+            << "Entry " << key << " not found in hash table\n";
+    }
+#   endif
+
+    return end();
+}
+
+
+template<class T, class Key, class Hash>
+typename Foam::HashTbl<T, Key, Hash>::const_iterator
+Foam::HashTbl<T, Key, Hash>::find
+(
+    const Key& key
+) const
+{
+    if (nElmts_)
+    {
+        const label hashIdx = hashKeyIndex(key);
+
+        for (hashedEntry* ep = table_[hashIdx]; ep; ep = ep->next_)
+        {
+            if (key == ep->key_)
+            {
+                return const_iterator(*this, ep, hashIdx);
+            }
+        }
+    }
+
+#   ifdef FULLDEBUG
+    if (debug)
+    {
+        Info<< "HashTbl<T, Key, Hash>::find(const Key& key) const : "
+            << "Entry " << key << " not found in hash table\n";
+    }
+#   endif
+
+    return cend();
+}
+
+
+template<class T, class Key, class Hash>
+Foam::List<Key> Foam::HashTbl<T, Key, Hash>::toc() const
+{
+    List<Key> tofc(nElmts_);
+    label i = 0;
+
+    for (const_iterator iter = cbegin(); iter != cend(); ++iter)
+    {
+        tofc[i++] = iter.key();
+    }
+
+    return tofc;
+}
+
+
+template<class T, class Key, class Hash>
+Foam::List<Key> Foam::HashTbl<T, Key, Hash>::sortedToc() const
+{
+    List<Key> sortedList = this->toc();
+    sort(sortedList);
+
+    return sortedList;
+}
+
+
+template<class T, class Key, class Hash>
+bool Foam::HashTbl<T, Key, Hash>::set
+(
+    const Key& key,
+    const T& newEntry,
+    const bool protect
+)
+{
+    if (!tableSize_)
+    {
+        resize(2);
+    }
+
+    const label hashIdx = hashKeyIndex(key);
+
+    hashedEntry* existing = 0;
+    hashedEntry* prev = 0;
+
+    for (hashedEntry* ep = table_[hashIdx]; ep; ep = ep->next_)
+    {
+        if (key == ep->key_)
+        {
+            existing = ep;
+            break;
+        }
+        prev = ep;
+    }
+
+    // not found, insert it at the head
+    if (!existing)
+    {
+        table_[hashIdx] = new hashedEntry(key, table_[hashIdx], newEntry);
+        nElmts_++;
+
+        if (double(nElmts_)/tableSize_ > 0.8)
+        {
+#           ifdef FULLDEBUG
+            if (debug)
+            {
+                Info<< "HashTbl<T, Key, Hash>::set"
+                    "(const Key& key, T newEntry) : "
+                    "Doubling table size\n";
+            }
+#           endif
+
+            resize(2*tableSize_);
+        }
+    }
+    else if (protect)
+    {
+        // found - but protected from overwriting
+        // this corresponds to the STL 'insert' convention
+#       ifdef FULLDEBUG
+        if (debug)
+        {
+            Info<< "HashTbl<T, Key, Hash>::set"
+                "(const Key& key, T newEntry, true) : "
+                "Cannot insert " << key << " already in hash table\n";
+        }
+#       endif
+        return false;
+    }
+    else
+    {
+        // found - overwrite existing entry
+        // this corresponds to the Perl convention
+        hashedEntry* ep = new hashedEntry(key, existing->next_, newEntry);
+
+        // replace existing element - within list or insert at the head
+        if (prev)
+        {
+            prev->next_ = ep;
+        }
+        else
+        {
+            table_[hashIdx] = ep;
+        }
+
+        delete existing;
+    }
+
+    return true;
+}
+
+
+template<class T, class Key, class Hash>
+bool Foam::HashTbl<T, Key, Hash>::erase(const iterator& cit)
+{
+    if (cit.elmtPtr_)    // note: endIter_ also has 0 elmtPtr_
+    {
+        iterator& it = const_cast<iterator&>(cit);
+
+        // Search element before elmtPtr_
+        hashedEntry* prev = 0;
+
+        for (hashedEntry* ep = table_[it.hashIndex_]; ep; ep = ep->next_)
+        {
+            if (ep == it.elmtPtr_)
+            {
+                break;
+            }
+            prev = ep;
+        }
+
+        if (prev)
+        {
+            // Have element before elmtPtr
+            prev->next_ = it.elmtPtr_->next_;
+            delete it.elmtPtr_;
+            it.elmtPtr_ = prev;
+        }
+        else
+        {
+            // elmtPtr is first element on SLList
+            table_[it.hashIndex_] = it.elmtPtr_->next_;
+            delete it.elmtPtr_;
+
+            // Search back for previous non-zero table entry
+            while (--it.hashIndex_ >= 0 && !table_[it.hashIndex_])
+            {}
+
+            if (it.hashIndex_ >= 0)
+            {
+                // In table entry search for last element
+                it.elmtPtr_ = table_[it.hashIndex_];
+
+                while (it.elmtPtr_ && it.elmtPtr_->next_)
+                {
+                    it.elmtPtr_ = it.elmtPtr_->next_;
+                }
+            }
+            else
+            {
+                // No previous found. Mark with special value which is
+                // - not end()/cend()
+                // - handled by operator++
+                it.elmtPtr_ = reinterpret_cast<hashedEntry*>(this);
+                it.hashIndex_ = -1;
+            }
+        }
+
+        nElmts_--;
+
+#       ifdef FULLDEBUG
+        if (debug)
+        {
+            Info<< "HashTbl<T, Key, Hash>::erase(iterator&) : "
+                << "hashedEntry " << it.elmtPtr_->key_ << " removed.\n";
+        }
+#       endif
+
+        return true;
+    }
+    else
+    {
+#       ifdef FULLDEBUG
+        if (debug)
+        {
+            Info<< "HashTbl<T, Key, Hash>::erase(iterator&) : "
+                << "cannot remove hashedEntry from hash table\n";
+        }
+#       endif
+
+        return false;
+    }
+}
+
+
+template<class T, class Key, class Hash>
+bool Foam::HashTbl<T, Key, Hash>::erase(const Key& key)
+{
+    iterator fnd = find(key);
+
+    if (fnd != end())
+    {
+        return erase(fnd);
+    }
+    else
+    {
+        return false;
+    }
+}
+
+
+template<class T, class Key, class Hash>
+Foam::label Foam::HashTbl<T, Key, Hash>::erase(const UList<Key>& keys)
+{
+    label count = 0;
+
+    // Remove listed keys from this table
+    if (this->size())
+    {
+        forAll(keys, keyI)
+        {
+            if (erase(keys[keyI]))
+            {
+                count++;
+            }
+        }
+    }
+
+    return count;
+}
+
+
+template<class T, class Key, class Hash>
+template<class AnyType>
+Foam::label Foam::HashTbl<T, Key, Hash>::erase
+(
+    const HashTbl<AnyType, Key, Hash>& rhs
+)
+{
+    label count = 0;
+
+    // Remove rhs elements from this table
+    if (this->size())
+    {
+        // NOTE: could further optimize depending on which hash is smaller
+        for (iterator iter = begin(); iter != end(); ++iter)
+        {
+            if (rhs.found(iter.key()) && erase(iter))
+            {
+                count++;
+            }
+        }
+    }
+
+    return count;
+}
+
+
+template<class T, class Key, class Hash>
+void Foam::HashTbl<T, Key, Hash>::resize(const label sz)
+{
+    label newSize = canonicalSize(sz);
+
+    if (newSize == tableSize_)
+    {
+#       ifdef FULLDEBUG
+        if (debug)
+        {
+            Info<< "HashTbl<T, Key, Hash>::resize(const label) : "
+                << "new table size == old table size\n";
+        }
+#       endif
+
+        return;
+    }
+
+    HashTbl<T, Key, Hash>* newTable = new HashTbl<T, Key, Hash>(newSize);
+
+    for (const_iterator iter = cbegin(); iter != cend(); ++iter)
+    {
+        newTable->insert(iter.key(), *iter);
+    }
+
+    label oldTableSize = tableSize_;
+    tableSize_ = newTable->tableSize_;
+    newTable->tableSize_ = oldTableSize;
+
+    hashedEntry** oldTable = table_;
+    table_ = newTable->table_;
+    newTable->table_ = oldTable;
+
+    delete newTable;
+}
+
+
+template<class T, class Key, class Hash>
+void Foam::HashTbl<T, Key, Hash>::clear()
+{
+    if (nElmts_)
+    {
+        for (label hashIdx = 0; hashIdx < tableSize_; hashIdx++)
+        {
+            if (table_[hashIdx])
+            {
+                hashedEntry* ep = table_[hashIdx];
+                while (hashedEntry* next = ep->next_)
+                {
+                    delete ep;
+                    ep = next;
+                }
+                delete ep;
+                table_[hashIdx] = 0;
+            }
+        }
+        nElmts_ = 0;
+    }
+}
+
+
+template<class T, class Key, class Hash>
+void Foam::HashTbl<T, Key, Hash>::clearStorage()
+{
+    clear();
+    resize(0);
+}
+
+
+template<class T, class Key, class Hash>
+void Foam::HashTbl<T, Key, Hash>::transfer(HashTbl<T, Key, Hash>& ht)
+{
+    // as per the Destructor
+    if (table_)
+    {
+        clear();
+        delete[] table_;
+    }
+
+    tableSize_ = ht.tableSize_;
+    ht.tableSize_ = 0;
+
+    table_ = ht.table_;
+    ht.table_ = NULL;
+
+    nElmts_ = ht.nElmts_;
+    ht.nElmts_ = 0;
+}
+
+
+// * * * * * * * * * * * * * * * Member Operators  * * * * * * * * * * * * * //
+
+template<class T, class Key, class Hash>
+void Foam::HashTbl<T, Key, Hash>::operator=
+(
+    const HashTbl<T, Key, Hash>& rhs
+)
+{
+    // Check for assignment to self
+    if (this == &rhs)
+    {
+        FatalErrorIn
+        (
+            "HashTbl<T, Key, Hash>::operator="
+            "(const HashTbl<T, Key, Hash>&)"
+        )   << "attempted assignment to self"
+            << abort(FatalError);
+    }
+
+    // could be zero-sized from a previous transfer()
+    if (!tableSize_)
+    {
+        resize(rhs.tableSize_);
+    }
+    else
+    {
+        clear();
+    }
+
+    for (const_iterator iter = rhs.cbegin(); iter != rhs.cend(); ++iter)
+    {
+        insert(iter.key(), *iter);
+    }
+}
+
+
+template<class T, class Key, class Hash>
+bool Foam::HashTbl<T, Key, Hash>::operator==
+(
+    const HashTbl<T, Key, Hash>& rhs
+) const
+{
+    // Are all my elements in rhs?
+    for (const_iterator iter = cbegin(); iter != cend(); ++iter)
+    {
+        const_iterator fnd = rhs.find(iter.key());
+
+        if (fnd == rhs.cend() || fnd() != iter())
+        {
+            return false;
+        }
+    }
+
+    // Are all rhs elements in me?
+    for (const_iterator iter = rhs.cbegin(); iter != rhs.cend(); ++iter)
+    {
+        const_iterator fnd = find(iter.key());
+
+        if (fnd == cend() || fnd() != iter())
+        {
+            return false;
+        }
+    }
+    return true;
+}
+
+
+template<class T, class Key, class Hash>
+bool Foam::HashTbl<T, Key, Hash>::operator!=
+(
+    const HashTbl<T, Key, Hash>& rhs
+) const
+{
+    return !(operator==(rhs));
+}
+
+
+// * * * * * * * * * * * * * * * Friend Operators  * * * * * * * * * * * * * //
+
+#include "HashTblIO.C"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/src/OpenFOAM/containers/HashTables/HashTbl/HashTbl.H b/src/OpenFOAM/containers/HashTables/HashTbl/HashTbl.H
new file mode 100644
index 0000000000..1c9f6db257
--- /dev/null
+++ b/src/OpenFOAM/containers/HashTables/HashTbl/HashTbl.H
@@ -0,0 +1,466 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 1991-2009 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 2 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, write to the Free Software Foundation,
+    Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+
+Class
+    Foam::HashTbl
+
+Description
+    An STL-conforming hash table.
+
+Note
+    Hashing index collisions are handled via chaining using a singly-linked
+    list with the colliding entry being added to the head of the linked
+    list. Thus copying the hash table (or indeed even resizing it) will
+    often result in a different hash order. Use a sorted table-of-contents
+    when the hash order is important.
+
+SourceFiles
+    HashTblI.H
+    HashTbl.C
+    HashTblIO.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef HashTbl_H
+#define HashTbl_H
+
+#include "label.H"
+#include "uLabel.H"
+#include "word.H"
+#include "Xfer.H"
+#include "className.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+// Forward declaration of friend functions and operators
+
+template<class T> class List;
+template<class T> class UList;
+template<class T, class Key, class Hash> class HashTbl;
+template<class T, class Key, class Hash> class HashPtrTable;
+
+template<class T, class Key, class Hash>
+Istream& operator>>(Istream&, HashTbl<T, Key, Hash>&);
+
+template<class T, class Key, class Hash>
+Ostream& operator<<(Ostream&, const HashTbl<T, Key, Hash>&);
+
+
+/*---------------------------------------------------------------------------*\
+                        Class HashTblName Declaration
+\*---------------------------------------------------------------------------*/
+
+TemplateName(HashTbl);
+
+
+/*---------------------------------------------------------------------------*\
+                          Class HashTbl Declaration
+\*---------------------------------------------------------------------------*/
+
+template<class T, class Key=word, class Hash=string::hash>
+class HashTbl
+:
+    public HashTblName
+{
+    // Private data type for table entries
+
+        struct hashedEntry
+        {
+            //- The lookup key
+            Key key_;
+
+            //- Pointer to next hashedEntry in sub-list
+            hashedEntry* next_;
+
+            //- The data object
+            T obj_;
+
+            //- Constructors
+
+                //- Construct given key, next pointer and object
+                inline hashedEntry
+                (
+                    const Key&,
+                    hashedEntry* next,
+                    const T& newEntry
+                );
+
+                //- Dissallow construction as copy
+                hashedEntry(const hashedEntry&);
+        };
+
+
+    // Private data: size of table, the table and current number of elements
+
+        //- The current number of elements in table
+        label nElmts_;
+
+        //- Number of primary entries allocated in table (not necessarily used)
+        label tableSize_;
+
+        //- The table of primary entries
+        hashedEntry** table_;
+
+
+    // Private Member Functions
+
+        //- Return a canonical (power-of-two) size
+        static label canonicalSize(const label);
+
+        //- Return the hash index of the Key within the current table size.
+        //  No checks for zero-sized tables.
+        inline label hashKeyIndex(const Key&) const;
+
+        //- Assign a new hashedEntry to a possibly already existing key
+        bool set(const Key&, const T& newElmt, bool protect);
+
+public:
+
+        //- Declare friendship with the HashPtrTable class
+        template<class T2, class Key2, class Hash2>
+        friend class HashPtrTable;
+
+
+    // Forward declaration of STL iterators
+
+        class iterator;
+        friend class iterator;
+
+        class const_iterator;
+        friend class const_iterator;
+
+
+    // Constructors
+
+        //- Construct given initial table size
+        HashTbl(const label size = 128);
+
+        //- Construct from Istream
+        HashTbl(Istream&, const label size = 128);
+
+        //- Construct as copy
+        HashTbl(const HashTbl<T, Key, Hash>&);
+
+        //- Construct by transferring the parameter contents
+        HashTbl(const Xfer<HashTbl<T, Key, Hash> >&);
+
+
+    // Destructor
+
+        ~HashTbl();
+
+
+    // Member Functions
+
+        // Access
+
+            //- Return number of elements in table.
+            inline label size() const;
+
+            //- Return true if the hash table is empty
+            inline bool empty() const;
+
+            //- Return true if hashedEntry is found in table
+            bool found(const Key&) const;
+
+            //- Find and return an iterator set at the hashedEntry
+            //  If not found iterator = end()
+            iterator find(const Key&);
+
+            //- Find and return an const_iterator set at the hashedEntry
+            //  If not found iterator = end()
+            const_iterator find(const Key&) const;
+
+            //- Return the table of contents
+            List<Key> toc() const;
+
+            //- Return the table of contents as a sorted list
+            List<Key> sortedToc() const;
+
+            //- Print information
+            Ostream& printInfo(Ostream&) const;
+
+        // Edit
+
+            //- Insert a new hashedEntry
+            inline bool insert(const Key&, const T& newElmt);
+
+            //- Assign a new hashedEntry, overwriting existing entries
+            inline bool set(const Key&, const T& newElmt);
+
+            //- Erase an hashedEntry specified by given iterator
+            bool erase(const iterator&);
+
+            //- Erase an hashedEntry specified by given key if in table
+            bool erase(const Key&);
+
+            //- Remove entries given by the listed keys from this HashTbl
+            //  Return the number of elements removed
+            label erase(const UList<Key>&);
+
+            //- Remove entries given by the given keys from this HashTbl
+            //  Return the number of elements removed.
+            //  The parameter HashTbl needs the same type of keys, but
+            //  but the type of values held is arbitrary.
+            template<class AnyType>
+            label erase(const HashTbl<AnyType, Key, Hash>&);
+
+            //- Resize the hash table for efficiency
+            void resize(const label newSize);
+
+            //- Clear all entries from table
+            void clear();
+
+            //- Clear the table entries and the table itself.
+            //  Equivalent to clear() followed by resize(0)
+            void clearStorage();
+
+            //- Transfer the contents of the argument table into this table
+            //  and annull the argument table.
+            void transfer(HashTbl<T, Key, Hash>&);
+
+            //- Transfer contents to the Xfer container
+            inline Xfer<HashTbl<T, Key, Hash> > xfer();
+
+
+    // Member Operators
+
+        //- Find and return an hashedEntry
+        inline T& operator[](const Key&);
+
+        //- Find and return an hashedEntry
+        inline const T& operator[](const Key&) const;
+
+        //- Find and return an hashedEntry, create it null if not present.
+        inline T& operator()(const Key&);
+
+        //- Assignment
+        void operator=(const HashTbl<T, Key, Hash>&);
+
+        //- Equality. Two hash tables are equal if all contents of first are
+        //  also in second and vice versa. So does not depend on table size or
+        //  order!
+        bool operator==(const HashTbl<T, Key, Hash>&) const;
+
+        //- The opposite of the equality operation. Takes linear time.
+        bool operator!=(const HashTbl<T, Key, Hash>&) const;
+
+
+
+    // STL type definitions
+
+        //- Type of values the HashTbl contains.
+        typedef T value_type;
+
+        //- Type that can be used for storing into HashTbl::value_type
+        //  objects.  This type is usually List::value_type&.
+        typedef T& reference;
+
+        //- Type that can be used for storing into constant
+        //  HashTbl::value_type objects.  This type is usually const
+        //  HashTbl::value_type&.
+        typedef const T& const_reference;
+
+        //- The type that can represent the size of a HashTbl.
+        typedef label size_type;
+
+
+    // STL iterator
+
+        //- An STL-conforming iterator
+        class iterator
+        {
+            friend class HashTbl;
+            friend class const_iterator;
+
+            // Private data
+
+                //- Reference to the HashTbl this is an iterator for
+                HashTbl<T, Key, Hash>& hashTable_;
+
+                //- Current element
+                hashedEntry* elmtPtr_;
+
+                //- Current hash index
+                label hashIndex_;
+
+        public:
+
+            // Constructors
+
+                //- Construct from hash table, element and hash index
+                inline iterator
+                (
+                    HashTbl<T, Key, Hash>& curHashTbl,
+                    hashedEntry* elmt,
+                    label hashIndex
+                );
+
+            // Member operators
+
+                inline void operator=(const iterator&);
+
+                inline bool operator==(const iterator&) const;
+                inline bool operator!=(const iterator&) const;
+
+                inline bool operator==(const const_iterator&) const;
+                inline bool operator!=(const const_iterator&) const;
+
+                inline T& operator*();
+                inline T& operator()();
+
+                inline const T& operator*() const;
+                inline const T& operator()() const;
+
+                inline iterator& operator++();
+                inline iterator operator++(int);
+
+                inline const Key& key() const;
+        };
+
+
+        //- iterator set to the begining of the HashTbl
+        inline iterator begin();
+
+        //- iterator set to beyond the end of the HashTbl
+        inline const iterator& end();
+
+
+    // STL const_iterator
+
+        //- An STL-conforming const_iterator
+        class const_iterator
+        {
+            friend class iterator;
+
+            // Private data
+
+                //- Reference to the HashTbl this is an iterator for
+                const HashTbl<T, Key, Hash>& hashTable_;
+
+                //- Current element
+                const hashedEntry* elmtPtr_;
+
+                //- Current hash index
+                label hashIndex_;
+
+
+        public:
+
+            // Constructors
+
+                //- Construct from hash table, element and hash index
+                inline const_iterator
+                (
+                    const HashTbl<T, Key, Hash>& curHashTbl,
+                    const hashedEntry* elmt,
+                    label hashIndex
+                );
+
+                //- Construct from the non-const iterator
+                inline const_iterator(const iterator&);
+
+
+            // Member operators
+
+                inline void operator=(const const_iterator&);
+
+                inline bool operator==(const const_iterator&) const;
+                inline bool operator!=(const const_iterator&) const;
+
+                inline bool operator==(const iterator&) const;
+                inline bool operator!=(const iterator&) const;
+
+                inline const T& operator*() const;
+                inline const T& operator()() const;
+
+                inline const_iterator& operator++();
+                inline const_iterator operator++(int);
+
+                inline const Key& key() const;
+        };
+
+
+        //- const_iterator set to the beginning of the HashTbl
+        inline const_iterator cbegin() const;
+
+        //- const_iterator set to beyond the end of the HashTbl
+        inline const const_iterator& cend() const;
+
+        //- const_iterator set to the beginning of the HashTbl
+        inline const_iterator begin() const;
+
+        //- const_iterator set to beyond the end of the HashTbl
+        inline const const_iterator& end() const;
+
+
+    // IOstream Operator
+
+        friend Istream& operator>> <T, Key, Hash>
+        (
+            Istream&,
+            HashTbl<T, Key, Hash>&
+        );
+
+        friend Ostream& operator<< <T, Key, Hash>
+        (
+            Ostream&,
+            const HashTbl<T, Key, Hash>&
+        );
+
+
+private:
+
+        //- iterator returned by end()
+        iterator endIter_;
+
+        //- const_iterator returned by end()
+        const_iterator endConstIter_;
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#   include "HashTblI.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#ifndef NoHashTblC
+#ifdef NoRepository
+#   include "HashTbl.C"
+#endif
+#endif
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/src/OpenFOAM/containers/HashTables/HashTbl/HashTblI.H b/src/OpenFOAM/containers/HashTables/HashTbl/HashTblI.H
new file mode 100644
index 0000000000..8dd27700b5
--- /dev/null
+++ b/src/OpenFOAM/containers/HashTables/HashTbl/HashTblI.H
@@ -0,0 +1,548 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 1991-2009 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 2 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, write to the Free Software Foundation,
+    Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+
+\*---------------------------------------------------------------------------*/
+
+#include "error.H"
+
+// * * * * * * * * * * * * * Private Member Classes * * * * * * * * * * * * //
+
+template<class T, class Key, class Hash>
+inline Foam::HashTbl<T, Key, Hash>::hashedEntry::hashedEntry
+(
+    const Key& key,
+    hashedEntry* next,
+    const T& newEntry
+)
+:
+    key_(key),
+    next_(next),
+    obj_(newEntry)
+{}
+
+
+// * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * * //
+
+template<class T, class Key, class Hash>
+inline Foam::label
+Foam::HashTbl<T, Key, Hash>::hashKeyIndex(const Key& key) const
+{
+    // size is power of two - this is the modulus
+    return Hash()(key) & (tableSize_ - 1);
+}
+
+
+// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
+
+template<class T, class Key, class Hash>
+inline Foam::label Foam::HashTbl<T, Key, Hash>::size() const
+{
+    return nElmts_;
+}
+
+
+template<class T, class Key, class Hash>
+inline bool Foam::HashTbl<T, Key, Hash>::empty() const
+{
+    return !nElmts_;
+}
+
+
+template<class T, class Key, class Hash>
+inline bool Foam::HashTbl<T, Key, Hash>::insert
+(
+    const Key& key,
+    const T& newEntry
+)
+{
+    return set(key, newEntry, true);
+}
+
+
+template<class T, class Key, class Hash>
+inline bool Foam::HashTbl<T, Key, Hash>::set
+(
+    const Key& key,
+    const T& newEntry
+)
+{
+    return set(key, newEntry, false);
+}
+
+
+template<class T, class Key, class Hash>
+inline Foam::Xfer<Foam::HashTbl<T, Key, Hash> >
+Foam::HashTbl<T, Key, Hash>::xfer()
+{
+    return xferMove(*this);
+}
+
+
+// * * * * * * * * * * * * * * * Member Operators  * * * * * * * * * * * * * //
+
+template<class T, class Key, class Hash>
+inline T& Foam::HashTbl<T, Key, Hash>::operator[](const Key& key)
+{
+    iterator iter = find(key);
+
+    if (iter == end())
+    {
+        FatalErrorIn("HashTbl<T, Key, Hash>::operator[](const Key&)")
+            << key << " not found in table.  Valid entries: "
+            << toc()
+            << exit(FatalError);
+    }
+
+    return *iter;
+}
+
+
+template<class T, class Key, class Hash>
+inline const T& Foam::HashTbl<T, Key, Hash>::operator[](const Key& key) const
+{
+    const_iterator iter = find(key);
+
+    if (iter == cend())
+    {
+        FatalErrorIn("HashTbl<T, Key, Hash>::operator[](const Key&) const")
+            << key << " not found in table.  Valid entries: "
+            << toc()
+            << exit(FatalError);
+    }
+
+    return *iter;
+}
+
+
+template<class T, class Key, class Hash>
+inline T& Foam::HashTbl<T, Key, Hash>::operator()(const Key& key)
+{
+    iterator iter = find(key);
+
+    if (iter == end())
+    {
+        insert(key, T());
+        return *find(key);
+    }
+    else
+    {
+        return *iter;
+    }
+}
+
+
+// * * * * * * * * * * * * * * * * STL iterator  * * * * * * * * * * * * * * //
+
+template<class T, class Key, class Hash>
+inline Foam::HashTbl<T, Key, Hash>::iterator::iterator
+(
+    HashTbl<T, Key, Hash>& hashTbl,
+    hashedEntry* elmt,
+    label hashIndex
+)
+:
+    hashTable_(hashTbl),
+    elmtPtr_(elmt),
+    hashIndex_(hashIndex)
+{}
+
+
+template<class T, class Key, class Hash>
+inline void Foam::HashTbl<T, Key, Hash>::iterator::operator=
+(
+    const iterator& iter
+)
+{
+    elmtPtr_ = iter.elmtPtr_;
+    hashIndex_ = iter.hashIndex_;
+}
+
+
+template<class T, class Key, class Hash>
+inline bool Foam::HashTbl<T, Key, Hash>::iterator::operator==
+(
+    const iterator& iter
+) const
+{
+    return elmtPtr_ == iter.elmtPtr_;
+}
+
+
+template<class T, class Key, class Hash>
+inline bool Foam::HashTbl<T, Key, Hash>::iterator::operator!=
+(
+    const iterator& iter
+) const
+{
+    return elmtPtr_ != iter.elmtPtr_;
+}
+
+
+template<class T, class Key, class Hash>
+inline bool Foam::HashTbl<T, Key, Hash>::iterator::operator==
+(
+    const const_iterator& iter
+) const
+{
+    return elmtPtr_ == iter.elmtPtr_;
+}
+
+
+template<class T, class Key, class Hash>
+inline bool Foam::HashTbl<T, Key, Hash>::iterator::operator!=
+(
+    const const_iterator& iter
+) const
+{
+    return elmtPtr_ != iter.elmtPtr_;
+}
+
+
+template<class T, class Key, class Hash>
+inline T&
+Foam::HashTbl<T, Key, Hash>::iterator::operator*()
+{
+    return elmtPtr_->obj_;
+}
+
+
+template<class T, class Key, class Hash>
+inline T&
+Foam::HashTbl<T, Key, Hash>::iterator::operator()()
+{
+    return elmtPtr_->obj_;
+}
+
+
+template<class T, class Key, class Hash>
+inline const T&
+Foam::HashTbl<T, Key, Hash>::iterator::operator*() const
+{
+    return elmtPtr_->obj_;
+}
+
+
+template<class T, class Key, class Hash>
+inline const T&
+Foam::HashTbl<T, Key, Hash>::iterator::operator()() const
+{
+    return elmtPtr_->obj_;
+}
+
+
+template<class T, class Key, class Hash>
+inline
+typename Foam::HashTbl<T, Key, Hash>::iterator&
+Foam::HashTbl<T, Key, Hash>::iterator::operator++()
+{
+    // Check for special value from erase. (sets hashIndex to -1)
+    if (hashIndex_ >= 0)
+    {
+        // Do we have additional elements on the SLList?
+        if (elmtPtr_ && elmtPtr_->next_)
+        {
+            elmtPtr_ = elmtPtr_->next_;
+            return *this;
+        }
+    }
+
+    // Step to the next table entry
+    while
+    (
+        ++hashIndex_ < hashTable_.tableSize_
+     && !(elmtPtr_ = hashTable_.table_[hashIndex_])
+    )
+    {}
+
+    if (hashIndex_ == hashTable_.tableSize_)
+    {
+        // make end iterator
+        elmtPtr_ = 0;
+        hashIndex_ = 0;
+    }
+    return *this;
+}
+
+
+template<class T, class Key, class Hash>
+inline typename Foam::HashTbl<T, Key, Hash>::iterator
+Foam::HashTbl<T, Key, Hash>::iterator::operator++
+(
+    int
+)
+{
+    iterator tmp = *this;
+    ++*this;
+    return tmp;
+}
+
+
+template<class T, class Key, class Hash>
+inline
+const Key& Foam::HashTbl<T, Key, Hash>::iterator::key() const
+{
+    return elmtPtr_->key_;
+}
+
+
+template<class T, class Key, class Hash>
+inline typename Foam::HashTbl<T, Key, Hash>::iterator
+Foam::HashTbl<T, Key, Hash>::begin()
+{
+    label i = 0;
+
+    if (nElmts_)
+    {
+        while (table_ && !table_[i] && ++i < tableSize_)
+        {}
+    }
+    else
+    {
+        i = tableSize_;
+    }
+
+    if (i == tableSize_)
+    {
+#       ifdef FULLDEBUG
+        if (debug)
+        {
+            Info<< "HashTbl is empty\n";
+        }
+#       endif
+
+        return HashTbl<T, Key, Hash>::endIter_;
+    }
+    else
+    {
+        return iterator(*this, table_[i], i);
+    }
+}
+
+
+template<class T, class Key, class Hash>
+inline const typename Foam::HashTbl<T, Key, Hash>::iterator&
+Foam::HashTbl<T, Key, Hash>::end()
+{
+    return HashTbl<T, Key, Hash>::endIter_;
+}
+
+
+// * * * * * * * * * * * * * * * STL const_iterator * * * * * * * * * * * * * //
+
+template<class T, class Key, class Hash>
+inline Foam::HashTbl<T, Key, Hash>::const_iterator::const_iterator
+(
+    const HashTbl<T, Key, Hash>& hashTbl,
+    const hashedEntry* elmt,
+    label hashIndex
+)
+:
+    hashTable_(hashTbl),
+    elmtPtr_(elmt),
+    hashIndex_(hashIndex)
+{}
+
+
+template<class T, class Key, class Hash>
+inline Foam::HashTbl<T, Key, Hash>::const_iterator::const_iterator
+(
+    const iterator& iter
+)
+:
+    hashTable_(iter.hashTable_),
+    elmtPtr_(iter.elmtPtr_),
+    hashIndex_(iter.hashIndex_)
+{}
+
+
+template<class T, class Key, class Hash>
+inline void Foam::HashTbl<T, Key, Hash>::const_iterator::operator=
+(
+    const const_iterator& iter
+)
+{
+    elmtPtr_ = iter.elmtPtr_;
+    hashIndex_ = iter.hashIndex_;
+}
+
+
+template<class T, class Key, class Hash>
+inline bool Foam::HashTbl<T, Key, Hash>::const_iterator::operator==
+(
+    const const_iterator& iter
+) const
+{
+    return elmtPtr_ == iter.elmtPtr_;
+}
+
+
+template<class T, class Key, class Hash>
+inline bool Foam::HashTbl<T, Key, Hash>::const_iterator::operator!=
+(
+    const const_iterator& iter
+) const
+{
+    return elmtPtr_ != iter.elmtPtr_;
+}
+
+
+template<class T, class Key, class Hash>
+inline bool Foam::HashTbl<T, Key, Hash>::const_iterator::operator==
+(
+    const iterator& iter
+) const
+{
+    return elmtPtr_ == iter.elmtPtr_;
+}
+
+
+template<class T, class Key, class Hash>
+inline bool Foam::HashTbl<T, Key, Hash>::const_iterator::operator!=
+(
+    const iterator& iter
+) const
+{
+    return elmtPtr_ != iter.elmtPtr_;
+}
+
+
+template<class T, class Key, class Hash>
+inline const T&
+Foam::HashTbl<T, Key, Hash>::const_iterator::operator*() const
+{
+    return elmtPtr_->obj_;
+}
+
+template<class T, class Key, class Hash>
+inline const T&
+Foam::HashTbl<T, Key, Hash>::const_iterator::operator()() const
+{
+    return elmtPtr_->obj_;
+}
+
+
+template<class T, class Key, class Hash>
+inline
+typename Foam::HashTbl<T, Key, Hash>::const_iterator&
+Foam::HashTbl<T, Key, Hash>::const_iterator::operator++()
+{
+    if
+    (
+        !(elmtPtr_ = elmtPtr_->next_)
+     && ++hashIndex_ < hashTable_.tableSize_
+     && !(elmtPtr_ = hashTable_.table_[hashIndex_])
+    )
+    {
+        while
+        (
+            ++hashIndex_ < hashTable_.tableSize_
+         && !(elmtPtr_ = hashTable_.table_[hashIndex_])
+        )
+        {}
+    }
+
+    return *this;
+}
+
+
+template<class T, class Key, class Hash>
+inline typename Foam::HashTbl<T, Key, Hash>::const_iterator
+Foam::HashTbl<T, Key, Hash>::const_iterator::operator++
+(
+    int
+)
+{
+    const_iterator tmp = *this;
+    ++*this;
+    return tmp;
+}
+
+
+template<class T, class Key, class Hash>
+inline
+const Key& Foam::HashTbl<T, Key, Hash>::const_iterator::key() const
+{
+    return elmtPtr_->key_;
+}
+
+
+template<class T, class Key, class Hash>
+inline typename Foam::HashTbl<T, Key, Hash>::const_iterator
+Foam::HashTbl<T, Key, Hash>::cbegin() const
+{
+    label i = 0;
+
+    if (nElmts_)
+    {
+        while (table_ && !table_[i] && ++i < tableSize_)
+        {}
+    }
+    else
+    {
+        i = tableSize_;
+    }
+
+    if (i == tableSize_)
+    {
+#       ifdef FULLDEBUG
+        if (debug)
+        {
+            Info<< "HashTbl is empty\n";
+        }
+#       endif
+
+        return HashTbl<T, Key, Hash>::endConstIter_;
+    }
+    else
+    {
+        return const_iterator(*this, table_[i], i);
+    }
+}
+
+
+template<class T, class Key, class Hash>
+inline const typename Foam::HashTbl<T, Key, Hash>::const_iterator&
+Foam::HashTbl<T, Key, Hash>::cend() const
+{
+    return HashTbl<T, Key, Hash>::endConstIter_;
+}
+
+
+template<class T, class Key, class Hash>
+inline typename Foam::HashTbl<T, Key, Hash>::const_iterator
+Foam::HashTbl<T, Key, Hash>::begin() const
+{
+    return this->cbegin();
+}
+
+
+template<class T, class Key, class Hash>
+inline const typename Foam::HashTbl<T, Key, Hash>::const_iterator&
+Foam::HashTbl<T, Key, Hash>::end() const
+{
+    return HashTbl<T, Key, Hash>::endConstIter_;
+}
+
+
+// ************************************************************************* //
diff --git a/src/OpenFOAM/containers/HashTables/HashTbl/HashTblIO.C b/src/OpenFOAM/containers/HashTables/HashTbl/HashTblIO.C
new file mode 100644
index 0000000000..ac438f77e9
--- /dev/null
+++ b/src/OpenFOAM/containers/HashTables/HashTbl/HashTblIO.C
@@ -0,0 +1,246 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 1991-2009 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 2 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, write to the Free Software Foundation,
+    Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+
+\*---------------------------------------------------------------------------*/
+
+#include "HashTbl.H"
+#include "Istream.H"
+#include "Ostream.H"
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+template<class T, class Key, class Hash>
+Foam::HashTbl<T, Key, Hash>::HashTbl(Istream& is, const label size)
+:
+    HashTblName(),
+    nElmts_(0),
+    tableSize_(canonicalSize(size)),
+    table_(new hashedEntry*[tableSize_]),
+    endIter_(*this, NULL, 0),
+    endConstIter_(*this, NULL, 0)
+{
+    for (label hashIdx = 0; hashIdx < tableSize_; hashIdx++)
+    {
+        table_[hashIdx] = 0;
+    }
+
+    operator>>(is, *this);
+}
+
+
+// * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * * //
+
+template<class T, class Key, class Hash>
+Foam::Ostream&
+Foam::HashTbl<T, Key, Hash>::printInfo(Ostream& os) const
+{
+    label used = 0;
+    label maxChain = 0;
+    unsigned avgChain = 0;
+
+    for (label hashIdx = 0; hashIdx < tableSize_; ++hashIdx)
+    {
+        label count = 0;
+        for (hashedEntry* ep = table_[hashIdx]; ep; ep = ep->next_)
+        {
+            ++count;
+        }
+
+        if (count)
+        {
+            ++used;
+            avgChain += count;
+
+            if (maxChain < count)
+            {
+                maxChain = count;
+            }
+        }
+    }
+
+    os  << "HashTbl<T,Key,Hash>"
+        << " elements:" << size() << " slots:" << used << "/" << tableSize_
+        << " chaining(avg/max):" << (used ? (float(avgChain)/used) : 0)
+        << "/" << maxChain << endl;
+
+    return os;
+}
+
+
+// * * * * * * * * * * * * * * * IOstream Operators  * * * * * * * * * * * * //
+
+template<class T, class Key, class Hash>
+Foam::Istream& Foam::operator>>
+(
+    Istream& is,
+    HashTbl<T, Key, Hash>& L
+)
+{
+    is.fatalCheck("operator>>(Istream&, HashTbl<T, Key, Hash>&)");
+
+    // Anull list
+    L.clear();
+
+    is.fatalCheck("operator>>(Istream&, HashTbl<T, Key, Hash>&)");
+
+    token firstToken(is);
+
+    is.fatalCheck
+    (
+        "operator>>(Istream&, HashTbl<T, Key, Hash>&) : "
+        "reading first token"
+    );
+
+    if (firstToken.isLabel())
+    {
+        label s = firstToken.labelToken();
+
+        // Read beginning of contents
+        char delimiter = is.readBeginList("HashTbl<T, Key, Hash>");
+
+        if (s)
+        {
+            if (2*s > L.tableSize_)
+            {
+                L.resize(2*s);
+            }
+
+            if (delimiter == token::BEGIN_LIST)
+            {
+                for (label i=0; i<s; i++)
+                {
+                    Key key;
+                    is >> key;
+                    L.insert(key, pTraits<T>(is));
+
+                    is.fatalCheck
+                    (
+                        "operator>>(Istream&, HashTbl<T, Key, Hash>&) : "
+                        "reading entry"
+                    );
+                }
+            }
+            else
+            {
+                FatalIOErrorIn
+                (
+                    "operator>>(Istream&, HashTbl<T, Key, Hash>&)",
+                    is
+                )   << "incorrect first token, '(', found " << firstToken.info()
+                    << exit(FatalIOError);
+            }
+        }
+
+        // Read end of contents
+        is.readEndList("HashTbl");
+    }
+    else if (firstToken.isPunctuation())
+    {
+        if (firstToken.pToken() != token::BEGIN_LIST)
+        {
+            FatalIOErrorIn
+            (
+                "operator>>(Istream&, HashTbl<T, Key, Hash>&)",
+                is
+            )   << "incorrect first token, '(', found " << firstToken.info()
+                << exit(FatalIOError);
+        }
+
+        token lastToken(is);
+        while
+        (
+           !(
+                lastToken.isPunctuation()
+             && lastToken.pToken() == token::END_LIST
+            )
+        )
+        {
+            is.putBack(lastToken);
+
+            Key key;
+            is >> key;
+
+            T element;
+            is >> element;
+
+            L.insert(key, element);
+
+            is.fatalCheck
+            (
+                "operator>>(Istream&, HashTbl<T, Key, Hash>&) : "
+                "reading entry"
+            );
+
+            is >> lastToken;
+        }
+    }
+    else
+    {
+        FatalIOErrorIn
+        (
+            "operator>>(Istream&, HashTbl<T, Key, Hash>&)",
+            is
+        )   << "incorrect first token, expected <int> or '(', found "
+            << firstToken.info()
+            << exit(FatalIOError);
+    }
+
+    is.fatalCheck("operator>>(Istream&, HashTbl<T, Key, Hash>&)");
+
+    return is;
+}
+
+
+template<class T, class Key, class Hash>
+Foam::Ostream& Foam::operator<<
+(
+    Ostream& os,
+    const HashTbl<T, Key, Hash>& L
+)
+{
+    // Write size and start delimiter
+    os << nl << L.size() << nl << token::BEGIN_LIST << nl;
+
+    // Write contents
+    for
+    (
+        typename HashTbl<T, Key, Hash>::const_iterator iter = L.cbegin();
+        iter != L.cend();
+        ++iter
+    )
+    {
+        os << iter.key() << token::SPACE << iter() << nl;
+    }
+
+    // Write end delimiter
+    os << token::END_LIST;
+
+    // Check state of IOstream
+    os.check("Ostream& operator<<(Ostream&, const HashTbl&)");
+
+    return os;
+}
+
+
+// ************************************************************************* //
diff --git a/src/OpenFOAM/containers/HashTables/HashTbl/HashTblName.C b/src/OpenFOAM/containers/HashTables/HashTbl/HashTblName.C
new file mode 100644
index 0000000000..61e198becb
--- /dev/null
+++ b/src/OpenFOAM/containers/HashTables/HashTbl/HashTblName.C
@@ -0,0 +1,33 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 1991-2009 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 2 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, write to the Free Software Foundation,
+    Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+
+\*---------------------------------------------------------------------------*/
+
+#include "HashTbl.H"
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+defineTypeNameAndDebug(Foam::HashTblName, 0);
+
+// ************************************************************************* //