Merge branch 'olesenm'

applications/test/HashTable/hashTableTest.C

@@ -40,6 +40,7 @@ using namespace Foam;
 int main()
 {
     HASHTABLE_CLASS<double> table1(13);
+    HASHTABLE_CLASS<double>::iterator iter;
 
     table1.insert("aaa", 1.0);
     table1.insert("aba", 2.0);
@@ -52,8 +53,12 @@ int main()
     table1.insert("adx", 9.0);
     table1.insert("aec", 10.0);
 
+    // erase by key
     table1.erase("aaw");
-    table1.erase("abs");
+
+    // erase by iterator
+    iter = table1.find("abs");
+    table1.erase(iter);
 
     Info<< "\ntable1 toc: " << table1.toc() << endl;
     Info<< "\ntable1 sortedToc: " << table1.sortedToc() << endl;

applications/test/HashTable3/Make/files

@@ -0,0 +1,3 @@
+hashTableTest3.C
+
+EXE = $(FOAM_USER_APPBIN)/hashTableTest3

applications/test/HashTable3/Make/options

@@ -0,0 +1,2 @@
+/* EXE_INC = -I$(LIB_SRC)/cfdTools/include */
+/* EXE_LIBS = -lfiniteVolume */

applications/test/HashTable3/hashTableTest3.C

@@ -0,0 +1,87 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  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
+        << " (size " << map.size() << " capacity " << map.capacity() << ") "
+        << "  " << timer.cpuTimeIncrement() << " s\n\n";
+
+    for (label i = 0; i < nSize; i++)
+    {
+        map.insert(i, i);
+    }
+    Info<< "Inserted " << nSize << " elements"
+        << " (size " << map.size() << " capacity " << map.capacity() << ") "
+        << timer.cpuTimeIncrement() << " s\n";
+
+    label elemI = 0;
+    for (label iLoop = 0; iLoop < nLoops; iLoop++)
+    {
+        for (label i = 0; i < nBase; i++)
+        {
+            map.erase(elemI++);
+        }
+
+        map.shrink();
+        Info<< "loop " << iLoop << " - Erased " << nBase << " elements"
+            << " (size " << map.size() << " capacity " << map.capacity() << ") "
+            << timer.cpuTimeIncrement() << " s\n";
+    }
+
+    return 0;
+}
+
+// ************************************************************************* //

applications/utilities/postProcessing/graphics/PV3FoamReader/Allwmake

@@ -1,21 +0,0 @@
-#!/bin/sh
-cd ${0%/*} || exit 1    # run from this directory
-set -x
-
-if [ -d "$ParaView_DIR" -a -r "$ParaView_DIR" ]
-then
-   case "$ParaView_VERSION" in
-   3*)
-      wmake libso vtkPV3Foam
-      (
-         cd PV3FoamReader
-         mkdir -p Make/$WM_OPTIONS > /dev/null 2>&1
-         cd Make/$WM_OPTIONS
-         cmake ../..
-         make
-      )
-      ;;
-   esac
-fi
-
-# ----------------------------------------------------------------- end-of-file

applications/utilities/postProcessing/graphics/PV3Readers/Allwmake

@@ -0,0 +1,16 @@
+#!/bin/sh
+cd ${0%/*} || exit 1    # run from this directory
+set -x
+
+if [ -d "$ParaView_DIR" -a -r "$ParaView_DIR" ]
+then
+    case "$ParaView_VERSION" in
+    3*)
+        wmake libso vtkPV3Readers
+        PV3blockMeshReader/Allwmake
+        PV3FoamReader/Allwmake
+    ;;
+    esac
+fi
+
+# ----------------------------------------------------------------- end-of-file

applications/utilities/postProcessing/graphics/PV3Readers/PV3FoamReader/Allwclean

@@ -2,6 +2,9 @@
 cd ${0%/*} || exit 1    # run from this directory
 set -x
 
+# deal with client/server vs combined plugins
+rm -f $FOAM_LIBBIN/libPV3FoamReader* 2>/dev/null
+
 rm -rf PV3FoamReader/Make
 wclean libso vtkPV3Foam
 

applications/utilities/postProcessing/graphics/PV3Readers/PV3FoamReader/Allwmake

@@ -0,0 +1,21 @@
+#!/bin/sh
+cd ${0%/*} || exit 1    # run from this directory
+set -x
+
+if [ -d "$ParaView_DIR" -a -r "$ParaView_DIR" ]
+then
+    case "$ParaView_VERSION" in
+    3*)
+        wmake libso vtkPV3Foam
+        (
+            cd PV3FoamReader
+            mkdir -p Make/$WM_OPTIONS > /dev/null 2>&1
+            cd Make/$WM_OPTIONS
+            cmake ../..
+            make
+        )
+        ;;
+    esac
+fi
+
+# ----------------------------------------------------------------- end-of-file

applications/utilities/postProcessing/graphics/PV3Readers/PV3FoamReader/PV3FoamReader/CMakeLists.txt

@@ -7,7 +7,7 @@
 # the pqReader.xml file contains xml defining readers with their
 # file extensions and descriptions.
 
-cmake_minimum_required(VERSION 2.4)
+CMAKE_MINIMUM_REQUIRED(VERSION 2.6)
 
 FIND_PACKAGE(ParaView REQUIRED)
 INCLUDE(${PARAVIEW_USE_FILE})
@@ -33,19 +33,46 @@ SET(
     "Single output directory for building all libraries."
 )
 
-# Build the server-side plugin
+
+#
+# Defined combined plugin
+#
+
+# Extend the auto-generated panel
+QT4_WRAP_CPP(MOC_SRCS pqPV3FoamReaderPanel.h)
+
+ADD_PARAVIEW_OBJECT_PANEL(IFACES IFACE_SRCS
+  CLASS_NAME pqPV3FoamReaderPanel
+  XML_NAME  PV3FoamReader  # name of SourceProxy in *SM.xml
+  XML_GROUP sources
+)
+
 ADD_PARAVIEW_PLUGIN(
     PV3FoamReader_SM "1.0"
     SERVER_MANAGER_XML PV3FoamReader_SM.xml
     SERVER_MANAGER_SOURCES vtkPV3FoamReader.cxx
+    GUI_INTERFACES ${IFACES}
+    GUI_SOURCES pqPV3FoamReaderPanel.cxx
+        ${MOC_SRCS} ${UI_SRCS} ${IFACE_SRCS}
+    GUI_RESOURCE_FILES PV3FoamReader.xml
 )
 
-# Build the client-side plugin
+# #
-ADD_PARAVIEW_PLUGIN(
+# # Define the server-side portion of the reader plugin
-    PV3FoamReader
+# #
-    "1.0"
+# ADD_PARAVIEW_PLUGIN(
-    GUI_RESOURCES PV3FoamReader.qrc
+#     PV3FoamReader_SM "1.0"
-)
+#     SERVER_MANAGER_XML PV3FoamReader_SM.xml
+#     SERVER_MANAGER_SOURCES vtkPV3FoamReader.cxx
+# )
+# #
+# # Define the client-side portion of the reader plugin
+# #
+# ADD_PARAVIEW_PLUGIN(
+#     PV3FoamReader "1.0"
+#     GUI_RESOURCES PV3FoamReader.qrc
+# )
+#
 
 TARGET_LINK_LIBRARIES(
     PV3FoamReader_SM

applications/utilities/postProcessing/graphics/PV3Readers/PV3FoamReader/PV3FoamReader/PV3FoamReader_SM.xml

@@ -16,6 +16,21 @@
       </Documentation>
     </StringVectorProperty>
 
+    <!-- Cache Mesh check-box -->
+    <IntVectorProperty
+      name="UiCacheMesh"
+      command="SetCacheMesh"
+      number_of_elements="1"
+      is_internal="1"
+      default_values="1"
+      animateable="0">
+      <BooleanDomain name="bool"/>
+      <Documentation>
+        Cache the fvMesh in memory.
+      </Documentation>
+    </IntVectorProperty>
+
+
     <!-- Send discrete time info to the animation panel -->
     <DoubleVectorProperty
       name="TimestepValues"
@@ -72,10 +87,11 @@
 
     <!-- Show Patch Names check-box -->
     <IntVectorProperty
-      name="ShowPatchNames"
+      name="UiShowPatchNames"
       command="SetShowPatchNames"
       number_of_elements="1"
       default_values="0"
+      is_internal="1"
       animateable="0">
       <BooleanDomain name="bool"/>
       <Documentation>
@@ -83,21 +99,7 @@
       </Documentation>
     </IntVectorProperty>
 
-    <!-- Cache Mesh check-box -->
+    <!-- Force GUI update check box -->
-    <IntVectorProperty
-      name="CacheMesh"
-      command="SetCacheMesh"
-      number_of_elements="1"
-      default_values="1"
-      animateable="0">
-      <BooleanDomain name="bool"/>
-      <Documentation>
-        Cache the fvMesh in memory.
-      </Documentation>
-    </IntVectorProperty>
-
-
-    <!-- Update GUI check box -->
     <IntVectorProperty
       name="UpdateGUI"
       command="SetUpdateGUI"
@@ -204,6 +206,14 @@
         </RequiredProperties>
       </ArraySelectionDomain>
     </StringVectorProperty>
+
+  <Hints>
+    <Property name="FileName" show="0"/>
+    <Property name="UiCacheMesh" show="0"/>
+    <Property name="UiShowPatchNames" show="0"/>
+  </Hints>
+
+
   </SourceProxy>
   </ProxyGroup>
 </ServerManagerConfiguration>

applications/utilities/postProcessing/graphics/PV3Readers/PV3FoamReader/PV3FoamReader/pqPV3FoamReaderPanel.cxx

@@ -0,0 +1,135 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  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
+
+\*---------------------------------------------------------------------------*/
+
+#include "pqPV3FoamReaderPanel.h"
+
+// QT
+#include <QGridLayout>
+#include <QCheckBox>
+#include <QLabel>
+#include <QLayout>
+#include <QString>
+#include <QtDebug>
+
+// Paraview<->QT UI
+#include "pqAnimationScene.h"
+#include "pqApplicationCore.h"
+#include "pqPipelineRepresentation.h"
+#include "pqServerManagerModel.h"
+#include "pqView.h"
+
+// Paraview Server Manager
+#include "vtkSMDoubleVectorProperty.h"
+#include "vtkSMIntVectorProperty.h"
+#include "vtkSMProperty.h"
+#include "vtkSMSourceProxy.h"
+
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+pqPV3FoamReaderPanel::pqPV3FoamReaderPanel
+(
+    pqProxy *proxy,
+    QWidget *p
+)
+:
+    pqAutoGeneratedObjectPanel(proxy, p),
+    sourceProxy_(vtkSMSourceProxy::SafeDownCast(this->proxy()))
+{
+    // create first sublayout (at top of the panel)
+    QGridLayout *sect1 = new QGridLayout();
+    this->PanelLayout->addLayout(sect1, 0, 0, 1, -1);
+
+
+    // checkbox for caching mesh
+    CacheMesh_ = new QCheckBox("Cache Mesh");
+    CacheMesh_->setChecked(true);
+
+    // checkbox for caching mesh
+    ShowPatchNames_ = new QCheckBox("Show Patch Names");
+    ShowPatchNames_->setChecked(false);
+
+    connect
+    (
+        CacheMesh_,
+        SIGNAL(stateChanged(int)),
+        this,
+        SLOT(CacheMeshToggled())
+    );
+
+    connect
+    (
+        ShowPatchNames_,
+        SIGNAL(stateChanged(int)),
+        this,
+        SLOT(ShowPatchNamesToggled())
+    );
+
+    sect1->addWidget(CacheMesh_);
+    sect1->addWidget(ShowPatchNames_);
+
+
+    // immediate update on the Server Manager side
+    vtkSMIntVectorProperty::SafeDownCast
+    (
+        sourceProxy_->GetProperty("UiCacheMesh")
+    )->SetImmediateUpdate(true);
+    vtkSMIntVectorProperty::SafeDownCast
+    (
+        sourceProxy_->GetProperty("UiShowPatchNames")
+    )->SetImmediateUpdate(true);
+}
+
+
+// * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * * //
+
+void pqPV3FoamReaderPanel::CacheMeshToggled()
+{
+    vtkSMIntVectorProperty::SafeDownCast
+    (
+        sourceProxy_->GetProperty("UiCacheMesh")
+    )->SetElement(0, CacheMesh_->isChecked());
+}
+
+
+void pqPV3FoamReaderPanel::ShowPatchNamesToggled()
+{
+    vtkSMIntVectorProperty::SafeDownCast
+    (
+        sourceProxy_->GetProperty("UiShowPatchNames")
+    )->SetElement(0, ShowPatchNames_->isChecked());
+
+    // update the active view
+    if (this->view())
+    {
+        this->view()->render();
+    }
+    // OR: update all views
+    // pqApplicationCore::instance()->render();
+}
+
+
+// ************************************************************************* //

applications/utilities/postProcessing/graphics/PV3Readers/PV3FoamReader/PV3FoamReader/pqPV3FoamReaderPanel.h

@@ -0,0 +1,98 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  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
+
+Class
+    pqPV3FoamReaderPanel
+
+Description
+    GUI modifications for the ParaView reader panel
+
+    A custom panel for the PV3FoamReader.
+
+SourceFiles
+    pqPV3FoamReaderPanel.cxx
+
+\*---------------------------------------------------------------------------*/
+#ifndef pqPV3FoamReaderPanel_h
+#define pqPV3FoamReaderPanel_h
+
+#include "pqAutoGeneratedObjectPanel.h"
+
+// Forward declaration of QT classes
+
+class QCheckBox;
+class QLineEdit;
+class QTimer;
+class QToolButton;
+
+// Forward declaration of ParaView classes
+class vtkSMSourceProxy;
+
+
+/*---------------------------------------------------------------------------*\
+                  Class pqPV3FoamReaderPanel Declaration
+\*---------------------------------------------------------------------------*/
+
+class pqPV3FoamReaderPanel
+:
+    public pqAutoGeneratedObjectPanel
+{
+    // Private data
+    Q_OBJECT;
+    typedef pqAutoGeneratedObjectPanel Superclass;
+
+    //- Server Manager Source Proxy
+    vtkSMSourceProxy* sourceProxy_;
+
+    //- CacheMesh checkbox
+    QCheckBox* CacheMesh_;
+
+    //- Show Patch Names checkbox
+    QCheckBox* ShowPatchNames_;
+
+protected slots:
+
+    void CacheMeshToggled();
+    void ShowPatchNamesToggled();
+
+
+public:
+
+    // Constructors
+
+        //- Construct from components
+        pqPV3FoamReaderPanel(pqProxy*, QWidget*);
+
+
+    //- Destructor
+    // virtual ~pqPV3FoamReaderPanel();
+
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //

applications/utilities/postProcessing/graphics/PV3Readers/PV3FoamReader/PV3FoamReader/vtkPV3FoamReader.cxx

@@ -1,18 +1,28 @@
-/*=========================================================================
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2008-2009 OpenCFD Ltd.
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
 
-  Program:   Visualization Toolkit
+    OpenFOAM is free software; you can redistribute it and/or modify it
-  Module:    $RCSfile: vtkPV3FoamReader.cxx,v $
+    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.
 
-  Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
-  All rights reserved.
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-  See Copyright.txt or http://www.kitware.com/Copyright.htm for details.
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
 
-     This software is distributed WITHOUT ANY WARRANTY; without even
+    You should have received a copy of the GNU General Public License
-     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+    along with OpenFOAM; if not, write to the Free Software Foundation,
-     PURPOSE.  See the above copyright notice for more information.
+    Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
-
-=========================================================================*/
 
+\*---------------------------------------------------------------------------*/
 #include "vtkPV3FoamReader.h"
 
 #include "pqApplicationCore.h"
@@ -33,10 +43,15 @@
 // Foam includes
 #include "vtkPV3Foam.H"
 
+#undef EXPERIMENTAL_TIME_CACHING
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
 vtkCxxRevisionMacro(vtkPV3FoamReader, "$Revision: 1.5$");
 vtkStandardNewMacro(vtkPV3FoamReader);
 
-#undef EXPERIMENTAL_TIME_CACHING
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
 
 vtkPV3FoamReader::vtkPV3FoamReader()
 {
@@ -109,11 +124,18 @@ vtkPV3FoamReader::vtkPV3FoamReader()
 }
 
 
+// * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
+
 vtkPV3FoamReader::~vtkPV3FoamReader()
 {
     vtkDebugMacro(<<"Deconstructor");
 
-    delete foamData_;
+    if (foamData_)
+    {
+        // remove patch names
+        updatePatchNamesView(false);
+        delete foamData_;
+    }
 
     if (FileName)
     {
@@ -140,6 +162,8 @@ vtkPV3FoamReader::~vtkPV3FoamReader()
 }
 
 
+// * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * * //
+
 // Do everything except set the output info
 int vtkPV3FoamReader::RequestInformation
 (
@@ -396,13 +420,35 @@ int vtkPV3FoamReader::RequestData
 }
 
 
+void vtkPV3FoamReader::SetShowPatchNames(const int val)
+{
+    if (ShowPatchNames != val)
+    {
+        ShowPatchNames = val;
+        updatePatchNamesView(ShowPatchNames);
+    }
+}
+
+
+
 void vtkPV3FoamReader::updatePatchNamesView(const bool show)
 {
     pqApplicationCore* appCore = pqApplicationCore::instance();
 
+    // need to check this, since our destructor calls this
+    if (!appCore)
+    {
+        return;
+    }
+
     // Server manager model for querying items in the server manager
     pqServerManagerModel* smModel = appCore->getServerManagerModel();
 
+    if (!smModel || !foamData_)
+    {
+        return;
+    }
+
     // Get all the pqRenderView instances
     QList<pqRenderView*> renderViews = smModel->findItems<pqRenderView*>();
 
@@ -414,6 +460,8 @@ void vtkPV3FoamReader::updatePatchNamesView(const bool show)
             show
         );
     }
+
+    // use refresh here?
 }
 
 

applications/utilities/postProcessing/graphics/PV3Readers/PV3FoamReader/PV3FoamReader/vtkPV3FoamReader.h

@@ -1,25 +1,52 @@
-/*=========================================================================
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2008-2009 OpenCFD Ltd.
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
 
-  Program:   Visualization Toolkit
+    OpenFOAM is free software; you can redistribute it and/or modify it
-  Module:    $RCSfile: vtkPV3FoamReader.h,v $
+    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.
 
-  Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
-  All rights reserved.
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-  See Copyright.txt or http://www.kitware.com/Copyright.htm for details.
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
 
-     This software is distributed WITHOUT ANY WARRANTY; without even
+    You should have received a copy of the GNU General Public License
-     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+    along with OpenFOAM; if not, write to the Free Software Foundation,
-     PURPOSE.  See the above copyright notice for more information.
+    Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
 
-=========================================================================*/
+Class
-// .NAME vtkPV3FoamReader - reads a dataset in OpenFOAM format
+    vtkPV3FoamReader
-// .SECTION Description
-// vtkPV3FoamReader creates an multiblock dataset.
-// It uses the OpenFOAM infrastructure (fvMesh, etc) to
-// handle mesh and field data.
 
-#ifndef __vtkPV3FoamReader_h
+Description
-#define __vtkPV3FoamReader_h
+    reads a dataset in OpenFOAM format
+
+    vtkPV3blockMeshReader creates an multiblock dataset.
+    It uses the OpenFOAM infrastructure (fvMesh, etc) to handle mesh and
+    field data.
+
+SourceFiles
+    vtkPV3blockMeshReader.cxx
+
+\*---------------------------------------------------------------------------*/
+#ifndef vtkPV3FoamReader_h
+#define vtkPV3FoamReader_h
+
+// VTK includes
+#include "vtkMultiBlockDataSetAlgorithm.h"
+
+// * * * * * * * * * * * * * Forward Declarations  * * * * * * * * * * * * * //
+
+// VTK forward declarations
+class vtkDataArraySelection;
+class vtkCallbackCommand;
 
 // Foam forward declarations
 namespace Foam
@@ -27,13 +54,10 @@ namespace Foam
     class vtkPV3Foam;
 }
 
-// VTK includes
-#include "vtkMultiBlockDataSetAlgorithm.h"
-
-// VTK forward declarations
-class vtkDataArraySelection;
-class vtkCallbackCommand;
 
+/*---------------------------------------------------------------------------*\
+                      Class vtkPV3FoamReader Declaration
+\*---------------------------------------------------------------------------*/
 
 class VTK_IO_EXPORT vtkPV3FoamReader
 :
@@ -54,16 +78,16 @@ public:
     vtkSetStringMacro(FileName);
     vtkGetStringMacro(FileName);
 
-    // Description:
-    // GUI update control
-    vtkSetMacro(UpdateGUI, int);
-    vtkGetMacro(UpdateGUI, int);
-
     // Description:
     // FOAM mesh caching control
     vtkSetMacro(CacheMesh, int);
     vtkGetMacro(CacheMesh, int);
 
+    // Description:
+    // GUI update control
+    vtkSetMacro(UpdateGUI, int);
+    vtkGetMacro(UpdateGUI, int);
+
     // Description:
     // FOAM extrapolate internal values onto the patches
     vtkSetMacro(ExtrapolatePatches, int);
@@ -80,7 +104,7 @@ public:
 
     // Description:
     // FOAM display patch names control
-    vtkSetMacro(ShowPatchNames, int);
+    virtual void SetShowPatchNames(int);
     vtkGetMacro(ShowPatchNames, int);
 
     // Description:

applications/utilities/postProcessing/graphics/PV3Readers/PV3FoamReader/vtkPV3Foam/Make/options

@@ -1,18 +1,20 @@
 EXE_INC = \
+    -I$(LIB_SRC)/meshTools/lnInclude \
     -I$(LIB_SRC)/finiteVolume/lnInclude \
     -I$(LIB_SRC)/lagrangian/basic/lnInclude \
-    -I$(LIB_SRC)/meshTools/lnInclude \
     -I$(ParaView_DIR)/VTK \
     -I$(ParaView_INST_DIR) \
     -I$(ParaView_INST_DIR)/VTK \
     -I$(ParaView_INST_DIR)/VTK/Common \
     -I$(ParaView_INST_DIR)/VTK/Filtering \
     -I$(ParaView_INST_DIR)/VTK/Rendering \
+    -I../../vtkPV3Readers/lnInclude \
     -I../PV3FoamReader
 
 LIB_LIBS = \
+    -lvtkPV3Readers \
+    -lmeshTools \
     -lfiniteVolume \
     -lgenericPatchFields \
     -llagrangian \
-    -lmeshTools \
     $(GLIBS)

applications/utilities/postProcessing/graphics/PV3Readers/PV3blockMeshReader/Allwclean

@@ -2,6 +2,9 @@
 cd ${0%/*} || exit 1    # run from this directory
 set -x
 
+# deal with client/server vs combined plugins
+rm -f $FOAM_LIBBIN/libPV3blockMeshReader*  2>/dev/null
+
 rm -rf PV3blockMeshReader/Make
 wclean libso vtkPV3blockMesh
 

applications/utilities/postProcessing/graphics/PV3Readers/PV3blockMeshReader/Allwmake

@@ -0,0 +1,21 @@
+#!/bin/sh
+cd ${0%/*} || exit 1    # run from this directory
+set -x
+
+if [ -d "$ParaView_DIR" -a -r "$ParaView_DIR" ]
+then
+    case "$ParaView_VERSION" in
+    3*)
+        wmake libso vtkPV3blockMesh
+        (
+            cd PV3blockMeshReader
+            mkdir -p Make/$WM_OPTIONS > /dev/null 2>&1
+            cd Make/$WM_OPTIONS
+            cmake ../..
+            make
+        )
+        ;;
+    esac
+fi
+
+# ----------------------------------------------------------------- end-of-file

applications/utilities/postProcessing/graphics/PV3Readers/PV3blockMeshReader/PV3blockMeshReader/CMakeLists.txt

@@ -7,7 +7,7 @@
 # the pqReader.xml file contains xml defining readers with their
 # file extensions and descriptions.
 
-cmake_minimum_required(VERSION 2.4)
+CMAKE_MINIMUM_REQUIRED(VERSION 2.6)
 
 FIND_PACKAGE(ParaView REQUIRED)
 INCLUDE(${PARAVIEW_USE_FILE})
@@ -33,19 +33,46 @@ SET(
     "Single output directory for building all libraries."
 )
 
-# Build the server-side plugin
+#
+# Define combined plugin
+#
+# Try to extend the auto-generated panel
+QT4_WRAP_CPP(MOC_SRCS pqPV3blockMeshReaderPanel.h)
+
+ADD_PARAVIEW_OBJECT_PANEL(IFACES IFACE_SRCS
+  CLASS_NAME pqPV3blockMeshReaderPanel
+  XML_NAME  PV3blockMeshReader # name of SourceProxy in *SM.xml
+  XML_GROUP sources
+)
+
 ADD_PARAVIEW_PLUGIN(
     PV3blockMeshReader_SM "1.0"
     SERVER_MANAGER_XML PV3blockMeshReader_SM.xml
-    SERVER_MANAGER_SOURCES vtkPV3blockMeshReader.cxx
+    SERVER_MANAGER_SOURCES  vtkPV3blockMeshReader.cxx
+    GUI_INTERFACES ${IFACES}
+    GUI_SOURCES pqPV3blockMeshReaderPanel.cxx
+        ${MOC_SRCS} ${UI_SRCS} ${IFACE_SRCS}
+    GUI_RESOURCE_FILES PV3blockMeshReader.xml
 )
 
+
+# #
+# # Define the server-side portion of the reader plugin
+# #
+# ADD_PARAVIEW_PLUGIN(PV3blockMeshReader_SM "1.0"
+#   SERVER_MANAGER_XML PV3blockMeshReader_SM.xml
+#   SERVER_MANAGER_SOURCES vtkPV3blockMeshReader.cxx
+# )
+# #
+# # Define the client-side portion of the reader plugin
+# #
+# ADD_PARAVIEW_PLUGIN(
+#     PV3blockMeshReader "1.0"
+#     GUI_RESOURCES PV3blockMeshReader.qrc
+# )
+
+
 # Build the client-side plugin
-ADD_PARAVIEW_PLUGIN(
-    PV3blockMeshReader
-    "1.0"
-    GUI_RESOURCES PV3blockMeshReader.qrc
-)
 
 TARGET_LINK_LIBRARIES(
     PV3blockMeshReader_SM

applications/utilities/postProcessing/graphics/PV3Readers/PV3blockMeshReader/PV3blockMeshReader/PV3blockMeshReader_SM.xml

@@ -16,14 +16,13 @@
       </Documentation>
     </StringVectorProperty>
 
-    <!-- Global settings -->
-
     <!-- Show Point Numbers check-box -->
     <IntVectorProperty
-      name="ShowPointNumbers"
+      name="UiShowPointNumbers"
       command="SetShowPointNumbers"
       number_of_elements="1"
       default_values="1"
+      is_internal="1"
       animateable="0">
       <BooleanDomain name="bool"/>
       <Documentation>
@@ -44,7 +43,6 @@
       </Documentation>
     </IntVectorProperty>
 
-
     <!-- Selections -->
 
     <!-- Available Parts (blocks) array -->
@@ -93,6 +91,11 @@
       </ArraySelectionDomain>
     </StringVectorProperty>
 
+  <Hints>
+    <Property name="FileName" show="0"/>
+    <Property name="UiShowPointNumbers" show="0"/>
+  </Hints>
+
   </SourceProxy>
   </ProxyGroup>
 </ServerManagerConfiguration>

applications/utilities/postProcessing/graphics/PV3Readers/PV3blockMeshReader/PV3blockMeshReader/pqPV3blockMeshReaderPanel.cxx

@@ -0,0 +1,109 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  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
+
+\*---------------------------------------------------------------------------*/
+
+#include "pqPV3blockMeshReaderPanel.h"
+
+// QT
+#include <QGridLayout>
+#include <QCheckBox>
+#include <QLabel>
+#include <QLayout>
+#include <QString>
+#include <QtDebug>
+
+// Paraview<->QT UI
+#include "pqAnimationScene.h"
+#include "pqApplicationCore.h"
+#include "pqPipelineRepresentation.h"
+#include "pqServerManagerModel.h"
+#include "pqView.h"
+
+// Paraview Server Manager
+#include "vtkSMDoubleVectorProperty.h"
+#include "vtkSMIntVectorProperty.h"
+#include "vtkSMProperty.h"
+#include "vtkSMSourceProxy.h"
+
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+pqPV3blockMeshReaderPanel::pqPV3blockMeshReaderPanel
+(
+    pqProxy *proxy,
+    QWidget *p
+)
+:
+    pqAutoGeneratedObjectPanel(proxy, p),
+    sourceProxy_(vtkSMSourceProxy::SafeDownCast(this->proxy()))
+{
+    // create first sublayout (at top of the panel)
+    QGridLayout *sect1 = new QGridLayout();
+    this->PanelLayout->addLayout(sect1, 0, 0, 1, -1);
+
+
+    // checkbox for showing point numbers
+    ShowPointNumbers_ = new QCheckBox("Show Point Numbers");
+    ShowPointNumbers_->setChecked(true);
+
+    connect
+    (
+        ShowPointNumbers_,
+        SIGNAL(stateChanged(int)),
+        this,
+        SLOT(ShowPointNumbersToggled())
+    );
+
+    sect1->addWidget(ShowPointNumbers_);
+
+
+    // immediate update on the Server Manager side
+    vtkSMIntVectorProperty::SafeDownCast
+    (
+        sourceProxy_->GetProperty("UiShowPointNumbers")
+    )->SetImmediateUpdate(true);
+
+}
+
+// * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * * //
+
+void pqPV3blockMeshReaderPanel::ShowPointNumbersToggled()
+{
+    vtkSMIntVectorProperty::SafeDownCast
+    (
+        sourceProxy_->GetProperty("UiShowPointNumbers")
+    )->SetElement(0, ShowPointNumbers_->isChecked());
+
+    // update the active view
+    if (this->view())
+    {
+        this->view()->render();
+    }
+    // OR: update all views
+    // pqApplicationCore::instance()->render();
+}
+
+
+// ************************************************************************* //

applications/utilities/postProcessing/graphics/PV3Readers/PV3blockMeshReader/PV3blockMeshReader/pqPV3blockMeshReaderPanel.h

@@ -0,0 +1,94 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  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
+
+Class
+    pqPV3blockMeshReaderPanel
+
+Description
+    GUI modifications for the ParaView reader panel
+
+    A custom panel for the PV3blockMeshReader.
+
+SourceFiles
+    pqPV3blockMeshReaderPanel.cxx
+
+\*---------------------------------------------------------------------------*/
+#ifndef pqPV3blockMeshReaderPanel_h
+#define pqPV3blockMeshReaderPanel_h
+
+#include "pqAutoGeneratedObjectPanel.h"
+
+// Forward declaration of QT classes
+
+class QCheckBox;
+class QLineEdit;
+class QTimer;
+class QToolButton;
+
+// Forward declaration of ParaView classes
+class vtkSMSourceProxy;
+
+
+/*---------------------------------------------------------------------------*\
+                  Class pqPV3blockMeshReaderPanel Declaration
+\*---------------------------------------------------------------------------*/
+
+class pqPV3blockMeshReaderPanel
+:
+    public pqAutoGeneratedObjectPanel
+{
+    // Private data
+    Q_OBJECT;
+    typedef pqAutoGeneratedObjectPanel Superclass;
+
+    //- Server Manager Source Proxy
+    vtkSMSourceProxy* sourceProxy_;
+
+    //- Show Point Numbers checkbox
+    QCheckBox* ShowPointNumbers_;
+
+protected slots:
+
+    void ShowPointNumbersToggled();
+
+
+public:
+
+    // Constructors
+
+        //- Construct from components
+        pqPV3blockMeshReaderPanel(pqProxy*, QWidget*);
+
+
+    //- Destructor
+    // virtual ~pqPV3blockMeshReaderPanel();
+
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //

applications/utilities/postProcessing/graphics/PV3Readers/PV3blockMeshReader/PV3blockMeshReader/vtkPV3blockMeshReader.cxx

@@ -1,18 +1,28 @@
-/*=========================================================================
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2008-2009 OpenCFD Ltd.
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
 
-  Program:   Visualization Toolkit
+    OpenFOAM is free software; you can redistribute it and/or modify it
-  Module:    $RCSfile: vtkPV3blockMeshReader.cxx,v $
+    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.
 
-  Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
-  All rights reserved.
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-  See Copyright.txt or http://www.kitware.com/Copyright.htm for details.
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
 
-     This software is distributed WITHOUT ANY WARRANTY; without even
+    You should have received a copy of the GNU General Public License
-     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+    along with OpenFOAM; if not, write to the Free Software Foundation,
-     PURPOSE.  See the above copyright notice for more information.
+    Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
-
-=========================================================================*/
 
+\*---------------------------------------------------------------------------*/
 #include "vtkPV3blockMeshReader.h"
 
 #include "pqApplicationCore.h"
@@ -33,9 +43,14 @@
 // Foam includes
 #include "vtkPV3blockMesh.H"
 
-vtkCxxRevisionMacro(vtkPV3blockMeshReader, "$Revision: 1.5$");
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+vtkCxxRevisionMacro(vtkPV3blockMeshReader, "$Revision:$");
 vtkStandardNewMacro(vtkPV3blockMeshReader);
 
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
 vtkPV3blockMeshReader::vtkPV3blockMeshReader()
 {
     Debug = 0;
@@ -76,11 +91,18 @@ vtkPV3blockMeshReader::vtkPV3blockMeshReader()
 }
 
 
+// * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
+
 vtkPV3blockMeshReader::~vtkPV3blockMeshReader()
 {
     vtkDebugMacro(<<"Deconstructor");
 
-    delete foamData_;
+    if (foamData_)
+    {
+        // remove point numbers
+        updatePointNumbersView(false);
+        delete foamData_;
+    }
 
     if (FileName)
     {
@@ -95,6 +117,8 @@ vtkPV3blockMeshReader::~vtkPV3blockMeshReader()
 }
 
 
+// * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * * //
+
 // Do everything except set the output info
 int vtkPV3blockMeshReader::RequestInformation
 (
@@ -211,16 +235,37 @@ int vtkPV3blockMeshReader::RequestData
 }
 
 
+
+void vtkPV3blockMeshReader::SetShowPointNumbers(const int val)
+{
+    if (ShowPointNumbers != val)
+    {
+        ShowPointNumbers = val;
+        updatePointNumbersView(ShowPointNumbers);
+    }
+}
+
+
 void vtkPV3blockMeshReader::updatePointNumbersView(const bool show)
 {
     pqApplicationCore* appCore = pqApplicationCore::instance();
 
+    // need to check this, since our destructor calls this
+    if (!appCore)
+    {
+        return;
+    }
+
     // Server manager model for querying items in the server manager
     pqServerManagerModel* smModel = appCore->getServerManagerModel();
+    if (!smModel || !foamData_)
+    {
+        return;
+    }
+
 
     // Get all the pqRenderView instances
     QList<pqRenderView*> renderViews = smModel->findItems<pqRenderView*>();
-
     for (int viewI=0; viewI<renderViews.size(); ++viewI)
     {
         foamData_->renderPointNumbers
@@ -229,6 +274,8 @@ void vtkPV3blockMeshReader::updatePointNumbersView(const bool show)
             show
         );
     }
+
+    // use refresh here?
 }
 
 

applications/utilities/postProcessing/graphics/PV3Readers/PV3blockMeshReader/PV3blockMeshReader/vtkPV3blockMeshReader.h

@@ -1,38 +1,61 @@
-/*=========================================================================
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2008-2009 OpenCFD Ltd.
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
 
-  Program:   Visualization Toolkit
+    OpenFOAM is free software; you can redistribute it and/or modify it
-  Module:    $RCSfile: vtkPV3blockMeshReader.h,v $
+    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.
 
-  Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
-  All rights reserved.
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-  See Copyright.txt or http://www.kitware.com/Copyright.htm for details.
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
 
-     This software is distributed WITHOUT ANY WARRANTY; without even
+    You should have received a copy of the GNU General Public License
-     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+    along with OpenFOAM; if not, write to the Free Software Foundation,
-     PURPOSE.  See the above copyright notice for more information.
+    Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
 
-=========================================================================*/
+Class
-// .NAME vtkPV3blockMeshReader - reads a dataset in OpenFOAM bockMesh format
+    vtkPV3blockMeshReader
-// .SECTION Description
-// vtkPV3blockMeshReader creates an multiblock dataset.
-// It uses the OpenFOAM infrastructure (blockMesh).
 
-#ifndef __vtkPV3blockMeshReader_h
+Description
-#define __vtkPV3blockMeshReader_h
+    reads a dataset in OpenFOAM bockMesh format
 
-// Foam forward declarations
+    vtkPV3blockMeshReader creates an multiblock dataset.
-namespace Foam
+    It uses the OpenFOAM infrastructure (blockMesh).
-{
+
-    class vtkPV3blockMesh;
+SourceFiles
-}
+    vtkPV3blockMeshReader.cxx
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef vtkPV3blockMeshReader_h
+#define vtkPV3blockMeshReader_h
 
 // VTK includes
 #include "vtkMultiBlockDataSetAlgorithm.h"
 
+// * * * * * * * * * * * * * Forward Declarations  * * * * * * * * * * * * * //
+
 // VTK forward declarations
 class vtkDataArraySelection;
 class vtkCallbackCommand;
 
+namespace Foam
+{
+    class vtkPV3blockMesh;
+}
+
+/*---------------------------------------------------------------------------*\
+                   Class vtkPV3blockMeshReader Declaration
+\*---------------------------------------------------------------------------*/
 
 class VTK_IO_EXPORT vtkPV3blockMeshReader
 :
@@ -49,15 +72,16 @@ public:
     vtkSetStringMacro(FileName);
     vtkGetStringMacro(FileName);
 
+    // Description:
+    // Display corner point labels
+    virtual void SetShowPointNumbers(int);
+    vtkGetMacro(ShowPointNumbers, int);
+
     // Description:
     // GUI update control
     vtkSetMacro(UpdateGUI, int);
     vtkGetMacro(UpdateGUI, int);
 
-    // Description:
-    // FOAM display patch names control
-    vtkSetMacro(ShowPointNumbers, int);
-    vtkGetMacro(ShowPointNumbers, int);
 
     // Description:
     // Parts (blocks) selection list control
@@ -121,6 +145,7 @@ protected:
 
     char* FileName;
 
+
 private:
 
     //- Disallow default bitwise copy construct
@@ -132,6 +157,8 @@ private:
     //- Add/remove point numbers to/from the view
     void updatePointNumbersView(const bool show);
 
+
+    //- Show Point Numbers
     int ShowPointNumbers;
 
     //- Dummy variable/switch to invoke a reader update

applications/utilities/postProcessing/graphics/PV3Readers/PV3blockMeshReader/vtkPV3blockMesh/Make/options

@@ -7,9 +7,11 @@ EXE_INC = \
     -I$(ParaView_INST_DIR)/VTK/Common \
     -I$(ParaView_INST_DIR)/VTK/Filtering \
     -I$(ParaView_INST_DIR)/VTK/Rendering \
+    -I../../vtkPV3Readers/lnInclude \
     -I../PV3blockMeshReader
 
 LIB_LIBS = \
+    -lvtkPV3Readers \
     -lmeshTools \
     -lblockMesh \
     $(GLIBS)

applications/utilities/postProcessing/graphics/PV3Readers/PV3blockMeshReader/vtkPV3blockMesh/vtkOpenFOAMPoints.H

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 1991-2009 OpenCFD Ltd.
+    \\  /    A nd           | Copyright (C) 2008-2009 OpenCFD Ltd.
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -44,6 +44,21 @@ inline void vtkInsertNextOpenFOAMPoint
     points->InsertNextPoint(p.x(), p.y(), p.z());
 }
 
+inline void vtkInsertNextOpenFOAMPoint
+(
+    vtkPoints *points,
+    const Foam::point& p,
+    const Foam::scalar scaleFactor
+)
+{
+    points->InsertNextPoint
+    (
+        p.x()*scaleFactor,
+        p.y()*scaleFactor,
+        p.z()*scaleFactor
+    );
+}
+
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
 #endif

applications/utilities/postProcessing/graphics/PV3Readers/PV3blockMeshReader/vtkPV3blockMesh/vtkPV3blockMesh.C

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 1991-2009 OpenCFD Ltd.
+    \\  /    A nd           | Copyright (C) 2008-2009 OpenCFD Ltd.
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -219,6 +219,14 @@ Foam::vtkPV3blockMesh::~vtkPV3blockMesh()
         Info<< "<end> Foam::vtkPV3blockMesh::~vtkPV3blockMesh" << endl;
     }
 
+    // Hmm. pointNumberTextActors are not getting removed
+    //
+    forAll(pointNumberTextActorsPtrs_, pointI)
+    {
+        pointNumberTextActorsPtrs_[pointI]->Delete();
+    }
+    pointNumberTextActorsPtrs_.clear();
+
     delete meshPtr_;
 }
 
@@ -376,6 +384,7 @@ void Foam::vtkPV3blockMesh::renderPointNumbers
     if (show && meshPtr_)
     {
         const pointField& cornerPts = meshPtr_->blockPointField();
+        const scalar scaleFactor = meshPtr_->scaleFactor();
 
         pointNumberTextActorsPtrs_.setSize(cornerPts.size());
         forAll(cornerPts, pointI)
@@ -399,9 +408,9 @@ void Foam::vtkPV3blockMesh::renderPointNumbers
 
             txt->GetPositionCoordinate()->SetValue
             (
-                cornerPts[pointI].x(),
+                cornerPts[pointI].x()*scaleFactor,
-                cornerPts[pointI].y(),
+                cornerPts[pointI].y()*scaleFactor,
-                cornerPts[pointI].z()
+                cornerPts[pointI].z()*scaleFactor
             );
 
             // Add text to each renderer

applications/utilities/postProcessing/graphics/PV3Readers/PV3blockMeshReader/vtkPV3blockMesh/vtkPV3blockMesh.H

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 1991-2009 OpenCFD Ltd.
+    \\  /    A nd           | Copyright (C) 2008-2009 OpenCFD Ltd.
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License

applications/utilities/postProcessing/graphics/PV3Readers/PV3blockMeshReader/vtkPV3blockMesh/vtkPV3blockMeshConvert.C

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 1991-2009 OpenCFD Ltd.
+    \\  /    A nd           | Copyright (C) 2008-2009 OpenCFD Ltd.
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -66,6 +66,7 @@ void Foam::vtkPV3blockMesh::convertMeshBlocks
     }
 
     int blockI = 0;
+    const scalar scaleFactor = blkMesh.scaleFactor();
 
     for
     (
@@ -103,7 +104,8 @@ void Foam::vtkPV3blockMesh::convertMeshBlocks
             vtkInsertNextOpenFOAMPoint
             (
                 vtkpoints,
-                blockPoints[blockLabels[ptI]]
+                blockPoints[blockLabels[ptI]],
+                scaleFactor
             );
 
             nodeIds[ptI] = ptI;
@@ -159,6 +161,7 @@ void Foam::vtkPV3blockMesh::convertMeshEdges
     const curvedEdgeList& edges = blkMesh.edges();
 
     int edgeI = 0;
+    const scalar scaleFactor = blkMesh.scaleFactor();
 
     for
     (
@@ -212,7 +215,12 @@ void Foam::vtkPV3blockMesh::convertMeshEdges
                 vtkIdType pointIds[edgePoints.size()];
                 forAll(edgePoints, ptI)
                 {
-                    vtkInsertNextOpenFOAMPoint(vtkpoints, edgePoints[ptI]);
+                    vtkInsertNextOpenFOAMPoint
+                    (
+                        vtkpoints,
+                        edgePoints[ptI],
+                        scaleFactor
+                    );
                     pointIds[ptI] = ptI;
                 }
 
@@ -266,6 +274,7 @@ void Foam::vtkPV3blockMesh::convertMeshCorners
     label datasetNo = 0;       // restart at dataset 0
 
     const pointField& blockPoints = meshPtr_->blockPointField();
+    const scalar& scaleFactor = meshPtr_->scaleFactor();
 
     if (debug)
     {
@@ -284,7 +293,12 @@ void Foam::vtkPV3blockMesh::convertMeshCorners
         vtkIdType pointId = 0;
         forAll(blockPoints, ptI)
         {
-            vtkInsertNextOpenFOAMPoint(vtkpoints, blockPoints[ptI]);
+            vtkInsertNextOpenFOAMPoint
+            (
+                vtkpoints,
+                blockPoints[ptI],
+                scaleFactor
+            );
 
             vtkcells->InsertNextCell(1, &pointId);
             pointId++;

applications/utilities/postProcessing/graphics/PV3Readers/PV3blockMeshReader/vtkPV3blockMesh/vtkPV3blockMeshUtils.C

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 1991-2009 OpenCFD Ltd.
+    \\  /    A nd           | Copyright (C) 2008-2009 OpenCFD Ltd.
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License

applications/utilities/postProcessing/graphics/PV3Readers/vtkPV3Readers/Make/files

@@ -0,0 +1,3 @@
+vtkPV3Readers.C
+
+LIB = $(FOAM_LIBBIN)/libvtkPV3Readers

applications/utilities/postProcessing/graphics/PV3Readers/vtkPV3Readers/Make/options

@@ -0,0 +1,10 @@
+EXE_INC = \
+    -I$(ParaView_DIR)/VTK \
+    -I$(ParaView_INST_DIR) \
+    -I$(ParaView_INST_DIR)/VTK \
+    -I$(ParaView_INST_DIR)/VTK/Common \
+    -I$(ParaView_INST_DIR)/VTK/Filtering \
+    -I$(ParaView_INST_DIR)/VTK/Rendering
+
+LIB_LIBS = \
+    $(GLIBS)

applications/utilities/postProcessing/graphics/PV3Readers/vtkPV3Readers/vtkPV3Readers.C

@@ -0,0 +1,330 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  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
+
+Description
+    Misc helper methods and utilities
+
+\*---------------------------------------------------------------------------*/
+
+#include "vtkPV3Readers.H"
+
+// Foam includes
+#include "IFstream.H"
+
+// VTK includes
+#include "vtkDataArraySelection.h"
+#include "vtkDataSet.h"
+#include "vtkMultiBlockDataSet.h"
+#include "vtkInformation.h"
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+defineTypeNameAndDebug(Foam::vtkPV3Readers, 0);
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+    //! @cond fileScope
+    //  Extract up to the first non-word characters
+    inline word getFirstWord(const char* str)
+    {
+        if (str)
+        {
+            label n = 0;
+            while (str[n] && word::valid(str[n]))
+            {
+                ++n;
+            }
+            return word(str, n, true);
+        }
+        else
+        {
+            return word::null;
+        }
+
+    }
+    //! @endcond fileScope
+
+} // End namespace Foam
+
+
+// * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
+
+void Foam::vtkPV3Readers::AddToBlock
+(
+    vtkMultiBlockDataSet* output,
+    vtkDataSet* dataset,
+    const partInfo& selector,
+    const label datasetNo,
+    const std::string& datasetName
+)
+{
+    const int blockNo = selector.block();
+
+    vtkDataObject* blockDO = output->GetBlock(blockNo);
+    vtkMultiBlockDataSet* block = vtkMultiBlockDataSet::SafeDownCast(blockDO);
+
+    if (!block)
+    {
+        if (blockDO)
+        {
+            FatalErrorIn("Foam::vtkPV3Readers::AddToBlock")
+                << "Block already has a vtkDataSet assigned to it"
+                << endl;
+            return;
+        }
+
+        block = vtkMultiBlockDataSet::New();
+        output->SetBlock(blockNo, block);
+        block->Delete();
+    }
+
+    if (debug)
+    {
+        Info<< "block[" << blockNo << "] has "
+            << block->GetNumberOfBlocks()
+            <<  " datasets prior to adding set " << datasetNo
+            <<  " with name: " << datasetName << endl;
+    }
+
+    block->SetBlock(datasetNo, dataset);
+
+    // name the block when assigning dataset 0
+    if (datasetNo == 0)
+    {
+        output->GetMetaData(blockNo)->Set
+        (
+            vtkCompositeDataSet::NAME(),
+            selector.name()
+        );
+    }
+
+    if (datasetName.size())
+    {
+        block->GetMetaData(datasetNo)->Set
+        (
+            vtkCompositeDataSet::NAME(),
+            datasetName.c_str()
+        );
+    }
+}
+
+
+vtkDataSet* Foam::vtkPV3Readers::GetDataSetFromBlock
+(
+    vtkMultiBlockDataSet* output,
+    const partInfo& selector,
+    const label datasetNo
+)
+{
+    const int blockNo = selector.block();
+
+    vtkDataObject* blockDO = output->GetBlock(blockNo);
+    vtkMultiBlockDataSet* block = vtkMultiBlockDataSet::SafeDownCast(blockDO);
+
+    if (block)
+    {
+        return vtkDataSet::SafeDownCast(block->GetBlock(datasetNo));
+    }
+
+    return 0;
+}
+
+
+// ununsed at the moment
+Foam::label Foam::vtkPV3Readers::GetNumberOfDataSets
+(
+    vtkMultiBlockDataSet* output,
+    const partInfo& selector
+)
+{
+    const int blockNo = selector.block();
+
+    vtkDataObject* blockDO = output->GetBlock(blockNo);
+    vtkMultiBlockDataSet* block = vtkMultiBlockDataSet::SafeDownCast(blockDO);
+    if (block)
+    {
+        return block->GetNumberOfBlocks();
+    }
+
+    return 0;
+}
+
+
+// Foam::word Foam::vtkPV3Readers::getPartName(int partId)
+// {
+//     return getFirstWord(reader_->GetPartArrayName(partId));
+// }
+
+
+Foam::wordHashSet Foam::vtkPV3Readers::getSelected
+(
+    vtkDataArraySelection* select
+)
+{
+    int nElem = select->GetNumberOfArrays();
+    wordHashSet selections(2*nElem);
+
+    for (int elemI=0; elemI < nElem; ++elemI)
+    {
+        if (select->GetArraySetting(elemI))
+        {
+            selections.insert(getFirstWord(select->GetArrayName(elemI)));
+        }
+    }
+
+    return selections;
+}
+
+
+Foam::wordHashSet Foam::vtkPV3Readers::getSelected
+(
+    vtkDataArraySelection* select,
+    const partInfo& selector
+)
+{
+    int nElem = select->GetNumberOfArrays();
+    wordHashSet selections(2*nElem);
+
+    for (int elemI = selector.start(); elemI < selector.end(); ++elemI)
+    {
+        if (select->GetArraySetting(elemI))
+        {
+            selections.insert(getFirstWord(select->GetArrayName(elemI)));
+        }
+    }
+
+    return selections;
+}
+
+
+Foam::stringList Foam::vtkPV3Readers::getSelectedArrayEntries
+(
+    vtkDataArraySelection* select
+)
+{
+    stringList selections(select->GetNumberOfArrays());
+    label nElem = 0;
+
+    forAll(selections, elemI)
+    {
+        if (select->GetArraySetting(elemI))
+        {
+            selections[nElem++] = select->GetArrayName(elemI);
+        }
+    }
+    selections.setSize(nElem);
+
+
+    if (debug)
+    {
+        label nElem = select->GetNumberOfArrays();
+        Info<< "available(";
+        for (int elemI = 0; elemI < nElem; ++elemI)
+        {
+            Info<< " \"" << select->GetArrayName(elemI) << "\"";
+        }
+        Info<< " )\nselected(";
+
+        forAll(selections, elemI)
+        {
+            Info<< " " << selections[elemI];
+        }
+        Info<< " )\n";
+    }
+
+    return selections;
+}
+
+
+Foam::stringList Foam::vtkPV3Readers::getSelectedArrayEntries
+(
+    vtkDataArraySelection* select,
+    const partInfo& selector
+)
+{
+    stringList selections(selector.size());
+    label nElem = 0;
+
+    for (int elemI = selector.start(); elemI < selector.end(); ++elemI)
+    {
+        if (select->GetArraySetting(elemI))
+        {
+            selections[nElem++] = select->GetArrayName(elemI);
+        }
+    }
+    selections.setSize(nElem);
+
+
+    if (debug)
+    {
+        Info<< "available(";
+        for (int elemI = selector.start(); elemI < selector.end(); ++elemI)
+        {
+            Info<< " \"" << select->GetArrayName(elemI) << "\"";
+        }
+        Info<< " )\nselected(";
+
+        forAll(selections, elemI)
+        {
+            Info<< " " << selections[elemI];
+        }
+        Info<< " )\n";
+    }
+
+    return selections;
+}
+
+
+void Foam::vtkPV3Readers::setSelectedArrayEntries
+(
+    vtkDataArraySelection* select,
+    const stringList& selections
+)
+{
+    const int nElem = select->GetNumberOfArrays();
+    select->DisableAllArrays();
+
+    // Loop through entries, setting values from selectedEntries
+    for (int elemI=0; elemI < nElem; ++elemI)
+    {
+        string arrayName(select->GetArrayName(elemI));
+
+        forAll(selections, elemI)
+        {
+            if (selections[elemI] == arrayName)
+            {
+                select->EnableArray(arrayName.c_str());
+                break;
+            }
+        }
+    }
+}
+
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+
+// ************************************************************************* //

applications/utilities/postProcessing/graphics/PV3Readers/vtkPV3Readers/vtkPV3Readers.H

@@ -0,0 +1,229 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  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
+
+Namespace
+    Foam::vtkPV3Readers
+
+Description
+    A collection of helper functions when building a reader interface in
+    ParaView3.
+
+SourceFiles
+    vtkPV3Readers.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef vtkPV3Readers_H
+#define vtkPV3Readers_H
+
+// do not include legacy strstream headers
+#ifndef  VTK_EXCLUDE_STRSTREAM_HEADERS
+# define VTK_EXCLUDE_STRSTREAM_HEADERS
+#endif
+
+#include "className.H"
+#include "fileName.H"
+#include "stringList.H"
+#include "wordList.H"
+#include "HashSet.H"
+
+
+// * * * * * * * * * * * * * Forward Declarations  * * * * * * * * * * * * * //
+
+class vtkDataArraySelection;
+class vtkDataSet;
+class vtkPoints;
+class vtkPV3FoamReader;
+class vtkRenderer;
+class vtkTextActor;
+class vtkMultiBlockDataSet;
+class vtkPolyData;
+class vtkUnstructuredGrid;
+class vtkIndent;
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+namespace vtkPV3Readers 
+{
+    //- Declare name of the class and its debug switch
+    NamespaceName("vtkPV3Readers");
+
+    //- Bookkeeping for GUI checklists and the multi-block organization
+    class partInfo
+    {
+        const char *name_;
+        int block_;
+        int start_;
+        int size_;
+
+    public:
+
+        partInfo(const char *name, const int blockNo=0)
+        :
+            name_(name),
+            block_(blockNo),
+            start_(-1),
+            size_(0)
+        {}
+
+        //- Return the block holding these datasets
+        int block() const
+        {
+            return block_;
+        }
+
+        //- Assign block number, return previous value
+        int block(int blockNo)
+        {
+            int prev = block_;
+            block_ = blockNo;
+            return prev;
+        }
+
+        const char* name() const
+        {
+            return name_;
+        }
+
+        int start() const
+        {
+            return start_;
+        }
+
+        int end() const
+        {
+            return start_ + size_;
+        }
+
+        int size() const
+        {
+            return size_;
+        }
+
+        bool empty() const
+        {
+            return !size_;
+        }
+
+        void reset()
+        {
+            start_ = -1;
+            size_ = 0;
+        }
+
+        //- Assign new start and reset the size
+        void operator=(const int i)
+        {
+            start_ = i;
+            size_ = 0;
+        }
+
+        //- Increment the size
+        void operator+=(const int n)
+        {
+            size_ += n;
+        }
+    };
+
+
+    //- Convenience method use to convert the readers from VTK 5
+    //  multiblock API to the current composite data infrastructure
+    void AddToBlock
+    (
+        vtkMultiBlockDataSet* output,
+        vtkDataSet* dataset,
+        const partInfo& selector,
+        const label datasetNo,
+        const std::string& datasetName
+    );
+
+
+    //- Convenience method use to convert the readers from VTK 5
+    // multiblock API to the current composite data infrastructure
+    vtkDataSet* GetDataSetFromBlock
+    (
+        vtkMultiBlockDataSet* output,
+        const partInfo& selector,
+        const label datasetNo
+    );
+
+    //- Convenience method use to convert the readers from VTK 5
+    // multiblock API to the current composite data infrastructure
+    // ununsed at the moment
+    label GetNumberOfDataSets
+    (
+        vtkMultiBlockDataSet* output,
+        const partInfo& selector
+    );
+
+
+    //- Retrieve the current selections as a wordHashSet
+    wordHashSet getSelected
+    (
+        vtkDataArraySelection* select
+    );
+
+
+    //- Retrieve a sub-list of the current selections
+    wordHashSet getSelected
+    (
+        vtkDataArraySelection*,
+        const partInfo&
+    );
+
+
+    //- Retrieve the current selections
+    stringList getSelectedArrayEntries(vtkDataArraySelection*);
+
+    //- Retrieve a sub-list of the current selections
+    stringList getSelectedArrayEntries
+    (
+        vtkDataArraySelection* select,
+        const partInfo& selector
+    );
+
+
+    //- Set selection(s)
+    void setSelectedArrayEntries
+    (
+        vtkDataArraySelection*,
+        const stringList&
+    );
+
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace vtkPV3
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //

applications/utilities/postProcessing/graphics/PV3blockMeshReader/Allwmake

@@ -1,21 +0,0 @@
-#!/bin/sh
-cd ${0%/*} || exit 1    # run from this directory
-set -x
-
-if [ -d "$ParaView_DIR" -a -r "$ParaView_DIR" ]
-then
-   case "$ParaView_VERSION" in
-   3*)
-      wmake libso vtkPV3blockMesh
-      (
-         cd PV3blockMeshReader
-         mkdir -p Make/$WM_OPTIONS > /dev/null 2>&1
-         cd Make/$WM_OPTIONS
-         cmake ../..
-         make
-      )
-      ;;
-   esac
-fi
-
-# ----------------------------------------------------------------- end-of-file

doc/codingStyleGuide.org

@@ -0,0 +1,275 @@
+#                            -*- mode: org; -*-
+#
+#+TITLE:                 OpenFOAM C++ style guide
+#+AUTHOR:                      OpenCFD Ltd.
+#+DATE:                       November 2009
+#+LINK:                  http://www.opencfd.co.uk
+#+OPTIONS: author:nil ^:{}
+
+* OpenFOAM C++ style guide
+
+*** General
+    + 80 character lines max
+    + The body of control statements (eg, if, else, while, etc).
+      always delineated with brace brackets
+
+    + stream output
+      << is always four characters after the start of the stream, so that the <<
+      symbols align, i.e.
+
+      Info<<
+      os  <<
+
+
+      so
+
+      WarningIn("className::functionName()")
+          << "Warning message"
+
+      NOT
+
+      WarningIn("className::functionName()")
+      << "Warning message"
+
+    + no unnecessary class section headers, i.e. remove
+
+      // * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
+
+      // Check
+
+      // Edit
+
+      // Write
+
+      if they contain nothing, even if planned for 'future use'
+
+    + class titles are centred
+
+     /*---------------------------------------------------------------------------*\
+                             Class exampleClass Declaration
+     \*---------------------------------------------------------------------------*/
+
+    NOT
+
+     /*---------------------------------------------------------------------------*\
+                    Class exampleClass Declaration
+     \*---------------------------------------------------------------------------*/
+
+*** .H Files
+    + header file spacing
+      Leave two empty lines between sections (as per functions in the .C file etc)
+
+    + use "//- Comment" comments in header file
+      + add descriptions to class data and functions
+    + destructor
+      If adding a comment to the destructor - use //- and code as a normal function:
+
+      //- Destructor
+      ~className();
+    + inline functions
+      Use inline functions where appropriate in a separate classNameI.H file.
+      Do not clutter up the header file with function bodies
+
+*** .C Files
+    + Do not open/close namespaces in a .C file
+      Fully scope the function name, i.e.
+
+      Foam::returnType Foam::className::functionName()
+
+      NOT
+
+      namespace Foam
+      {
+          ...
+
+          returnType className::functionName()
+
+          ...
+      }
+
+      EXCEPTION
+
+      When there are multiple levels of namespace, they may be used in the .C
+      file, i.e.
+
+      namespace Foam
+      {
+      namespace compressible
+      {
+      namespace RASModels
+      {
+
+          ...
+
+      } // End namespace RASModels
+      } // End namespace compressible
+      } // End namespace Foam
+
+    + Use two empty lines between functions
+
+*** Coding Practise
+    + passing data as arguments or return
+      Pass label and scalar as copy, anything bigger by reference
+    + const
+      Use everywhere it is applicable.
+    + variable initialisation using "="
+
+      const className& variableName = otherClass.data();
+
+      NOT
+
+      const className& variableName(otherClass.data());
+
+    + virtual functions
+      If a class is virtual - make all derived classes virtual.
+
+*** Conditional Statements
+    if (condition)
+    {
+        code;
+    }
+
+    OR
+
+    if
+    (
+       long condition
+    )
+    {
+        code;
+    }
+
+    NOT (no space between "if" and "(")
+
+    if(condition)
+    {
+        code;
+    }
+
+*** `for' Loops
+    for (i = 0; i < maxI; i++)
+    {
+        code;
+    }
+
+    OR
+
+    for
+    (
+        i = 0;
+        i < maxI;
+        i++
+    )
+    {
+        code;
+    }
+
+    NOT (no space between "for" and "(")
+
+    for(i = 0; i < maxI; i++)
+    {
+        code;
+    }
+
+*** `forAll' loops
+    like for loops, but
+
+    forAll(
+
+    NOT
+
+    forAll (
+
+*** Splitting Over Multiple Lines
+   + splitting return type and function name
+     + split initially after the function return type and left align
+
+     + do not put "const" onto it's own line - use a split to keep it with the
+       function name and arguments.
+
+     so:
+
+     const Foam::longReturnTypeName&
+     Foam::longClassName::longFunctionName const
+
+     NOT
+
+     const Foam::longReturnTypeName&
+         Foam::longClassName::longFunctionName const
+
+     NOR
+
+     const Foam::longReturnTypeName& Foam::longClassName::longFunctionName
+     const
+
+     NOR
+
+     const Foam::longReturnTypeName& Foam::longClassName::
+     longFunctionName const
+
+
+     + if need to split again, split at the function name (leaving behind the
+         preceding scoping "::"'s), and again, left align, i.e.
+
+       const Foam::longReturnTypeName&
+       Foam::veryveryveryverylongClassName::
+       veryveryveryverylongFunctionName const
+
+   + splitting long lines at an "="
+
+     Indent after split
+
+     variableName =
+         longClassName.longFunctionName(longArgument);
+
+     OR (where necessary)
+
+     variableName =
+         longClassName.longFunctionName
+         (
+             longArgument1,
+             longArgument2
+         );
+
+     NOT
+
+     variableName =
+     longClassName.longFunctionName(longArgument);
+
+     NOR
+
+     variableName = longClassName.longFunctionName
+     (
+         longArgument1,
+         longArgument2
+     );
+
+*** Maths and Logic
+    + operator spacing
+      + a + b, a - b
+      + a*b, a/b
+      + a & b, a ^ b
+      + a = b, a != b
+      + a < b, a > b, a >= b, a <= b
+      + a || b, a && b
+
+    + splitting formulae over several lines
+      Split and indent as per "splitting long lines at an "=""
+      with the operator on the lower line.  Align operator so that first
+      variable, function or bracket on the next line is 4 spaces indented i.e.
+
+      variableName =
+          a*(a + b)
+        - exp(c/d)
+         *(k + t)
+
+    + splitting logical tests over several lines
+
+      indent operator so that the next variable to test is aligned with the
+      four space indentation, i.e.
+
+      if
+      (
+          a == true
+       && b == c
+      )

src/OpenFOAM/Make/files

@@ -61,8 +61,8 @@ $(sha1)/SHA1Digest.C
 
 primitives/random/Random.C
 
-containers/HashTables/HashTable/HashTableName.C
+containers/HashTables/HashTable/HashTableCore.C
-containers/HashTables/StaticHashTable/StaticHashTableName.C
+containers/HashTables/StaticHashTable/StaticHashTableCore.C
 containers/Lists/SortableList/ParSortableListName.C
 containers/Lists/PackedList/PackedListName.C
 containers/Lists/ListOps/ListOps.C

src/OpenFOAM/containers/HashTables/HashTable/HashTable.C

@@ -30,44 +30,15 @@ License
 #include "HashTable.H"
 #include "List.H"
 
-// * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * * //
-
-template<class T, class Key, class Hash>
-Foam::label Foam::HashTable<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::HashTable<T, Key, Hash>::HashTable(const label size)
 :
-    HashTableName(),
+    HashTableCore(),
     nElmts_(0),
-    tableSize_(canonicalSize(size)),
+    tableSize_(HashTableCore::canonicalSize(size)),
-    table_(NULL),
+    table_(NULL)
-    endIter_(*this, NULL, 0),
-    endConstIter_(*this, NULL, 0)
 {
     if (tableSize_)
     {
@@ -84,12 +55,10 @@ Foam::HashTable<T, Key, Hash>::HashTable(const label size)
 template<class T, class Key, class Hash>
 Foam::HashTable<T, Key, Hash>::HashTable(const HashTable<T, Key, Hash>& ht)
 :
-    HashTableName(),
+    HashTableCore(),
     nElmts_(0),
     tableSize_(ht.tableSize_),
-    table_(NULL),
+    table_(NULL)
-    endIter_(*this, NULL, 0),
-    endConstIter_(*this, NULL, 0)
 {
     if (tableSize_)
     {
@@ -113,12 +82,10 @@ Foam::HashTable<T, Key, Hash>::HashTable
     const Xfer<HashTable<T, Key, Hash> >& ht
 )
 :
-    HashTableName(),
+    HashTableCore(),
     nElmts_(0),
     tableSize_(0),
-    table_(NULL),
+    table_(NULL)
-    endIter_(*this, NULL, 0),
-    endConstIter_(*this, NULL, 0)
 {
     transfer(ht());
 }
@@ -182,7 +149,7 @@ Foam::HashTable<T, Key, Hash>::find
         {
             if (key == ep->key_)
             {
-                return iterator(*this, ep, hashIdx);
+                return iterator(this, ep, hashIdx);
             }
         }
     }
@@ -195,7 +162,7 @@ Foam::HashTable<T, Key, Hash>::find
     }
 #   endif
 
-    return end();
+    return iterator();
 }
 
 
@@ -214,7 +181,7 @@ Foam::HashTable<T, Key, Hash>::find
         {
             if (key == ep->key_)
             {
-                return const_iterator(*this, ep, hashIdx);
+                return const_iterator(this, ep, hashIdx);
             }
         }
     }
@@ -227,32 +194,32 @@ Foam::HashTable<T, Key, Hash>::find
     }
 #   endif
 
-    return cend();
+    return const_iterator();
 }
 
 
 template<class T, class Key, class Hash>
 Foam::List<Key> Foam::HashTable<T, Key, Hash>::toc() const
 {
-    List<Key> tofc(nElmts_);
+    List<Key> keys(nElmts_);
-    label i = 0;
+    label keyI = 0;
 
     for (const_iterator iter = cbegin(); iter != cend(); ++iter)
     {
-        tofc[i++] = iter.key();
+        keys[keyI++] = iter.key();
     }
 
-    return tofc;
+    return keys;
 }
 
 
 template<class T, class Key, class Hash>
 Foam::List<Key> Foam::HashTable<T, Key, Hash>::sortedToc() const
 {
-    List<Key> sortedList = this->toc();
+    List<Key> sortedLst = this->toc();
-    sort(sortedList);
+    sort(sortedLst);
 
-    return sortedList;
+    return sortedLst;
 }
 
 
@@ -290,7 +257,7 @@ bool Foam::HashTable<T, Key, Hash>::set
         table_[hashIdx] = new hashedEntry(key, table_[hashIdx], newEntry);
         nElmts_++;
 
-        if (double(nElmts_)/tableSize_ > 0.8)
+        if (double(nElmts_)/tableSize_ > 0.8 && tableSize_ < maxTableSize)
         {
 #           ifdef FULLDEBUG
             if (debug)
@@ -342,18 +309,22 @@ bool Foam::HashTable<T, Key, Hash>::set
 
 
 template<class T, class Key, class Hash>
-bool Foam::HashTable<T, Key, Hash>::erase(const iterator& cit)
+bool Foam::HashTable<T, Key, Hash>::iteratorBase::erase()
 {
-    if (cit.elmtPtr_)    // note: endIter_ also has 0 elmtPtr_
+    // note: entryPtr_ is NULL for end(), so this catches that too
+    if (entryPtr_)
     {
-        iterator& it = const_cast<iterator&>(cit);
+        // Search element before entryPtr_
-
-        // Search element before elmtPtr_
         hashedEntry* prev = 0;
 
-        for (hashedEntry* ep = table_[it.hashIndex_]; ep; ep = ep->next_)
+        for
+        (
+            hashedEntry* ep = hashTable_->table_[hashIndex_];
+            ep;
+            ep = ep->next_
+        )
         {
-            if (ep == it.elmtPtr_)
+            if (ep == entryPtr_)
             {
                 break;
             }
@@ -362,98 +333,76 @@ bool Foam::HashTable<T, Key, Hash>::erase(const iterator& cit)
 
         if (prev)
         {
-            // Have element before elmtPtr
+            // has an element before entryPtr - reposition to there
-            prev->next_ = it.elmtPtr_->next_;
+            prev->next_ = entryPtr_->next_;
-            delete it.elmtPtr_;
+            delete entryPtr_;
-            it.elmtPtr_ = prev;
+            entryPtr_ = prev;
         }
         else
         {
-            // elmtPtr is first element on SLList
+            // entryPtr was first element on SLList
-            table_[it.hashIndex_] = it.elmtPtr_->next_;
+            hashTable_->table_[hashIndex_] = entryPtr_->next_;
-            delete it.elmtPtr_;
+            delete entryPtr_;
 
-            // Search back for previous non-zero table entry
+            // assign any non-NULL pointer value so it doesn't look
-            while (--it.hashIndex_ >= 0 && !table_[it.hashIndex_])
+            // like end()/cend()
-            {}
+            entryPtr_ = reinterpret_cast<hashedEntry*>(this);
 
-            if (it.hashIndex_ >= 0)
+            // Mark with special hashIndex value to signal it has been rewound.
-            {
+            // The next increment will bring it back to the present location.
-                // In table entry search for last element
+            //
-                it.elmtPtr_ = table_[it.hashIndex_];
+            // From the current position 'curPos', we wish to continue at
-
+            // prevPos='curPos-1', which we mark as markPos='-curPos-1'.
-                while (it.elmtPtr_ && it.elmtPtr_->next_)
+            // The negative lets us notice it is special, the extra '-1'
-                {
+            // is needed to avoid ambiguity for position '0'.
-                    it.elmtPtr_ = it.elmtPtr_->next_;
+            // To retrieve prevPos, we would later use '-(markPos+1) - 1'
-                }
+            hashIndex_ = -hashIndex_ - 1;
-            }
-            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_--;
+        hashTable_->nElmts_--;
-
-#       ifdef FULLDEBUG
-        if (debug)
-        {
-            Info<< "HashTable<T, Key, Hash>::erase(iterator&) : "
-                << "hashedEntry " << it.elmtPtr_->key_ << " removed.\n";
-        }
-#       endif
 
         return true;
     }
     else
     {
-#       ifdef FULLDEBUG
-        if (debug)
-        {
-            Info<< "HashTable<T, Key, Hash>::erase(iterator&) : "
-                << "cannot remove hashedEntry from hash table\n";
-        }
-#       endif
-
         return false;
     }
 }
 
 
+
+// NOTE:
+// We use (const iterator&) here, but manipulate its contents anyhow.
+// The parameter should be (iterator&), but then the compiler doesn't find
+// it correctly and tries to call as (iterator) instead.
+//
+template<class T, class Key, class Hash>
+bool Foam::HashTable<T, Key, Hash>::erase(const iterator& iter)
+{
+    // adjust iterator after erase
+    return const_cast<iterator&>(iter).erase();
+}
+
+
 template<class T, class Key, class Hash>
 bool Foam::HashTable<T, Key, Hash>::erase(const Key& key)
 {
-    iterator fnd = find(key);
+    return erase(find(key));
-
-    if (fnd != end())
-    {
-        return erase(fnd);
-    }
-    else
-    {
-        return false;
-    }
 }
 
 
 template<class T, class Key, class Hash>
 Foam::label Foam::HashTable<T, Key, Hash>::erase(const UList<Key>& keys)
 {
+    const label nTotal = nElmts_;
     label count = 0;
 
-    // Remove listed keys from this table
+    // Remove listed keys from this table - terminates early if possible
-    if (this->size())
+    for (label keyI = 0; count < nTotal && keyI < keys.size(); ++keyI)
     {
-        forAll(keys, keyI)
+        if (erase(keys[keyI]))
         {
-            if (erase(keys[keyI]))
+            count++;
-            {
-                count++;
-            }
         }
     }
 
@@ -462,24 +411,21 @@ Foam::label Foam::HashTable<T, Key, Hash>::erase(const UList<Key>& keys)
 
 
 template<class T, class Key, class Hash>
-template<class AnyType>
+template<class AnyType, class AnyHash>
 Foam::label Foam::HashTable<T, Key, Hash>::erase
 (
-    const HashTable<AnyType, Key, Hash>& rhs
+    const HashTable<AnyType, Key, AnyHash>& rhs
 )
 {
     label count = 0;
 
-    // Remove rhs elements from this table
+    // Remove rhs keys from this table - terminates early if possible
-    if (this->size())
+    // Could optimize depending on which hash is smaller ...
+    for (iterator iter = begin(); iter != end(); ++iter)
     {
-        // NOTE: could further optimize depending on which hash is smaller
+        if (rhs.found(iter.key()) && erase(iter))
-        for (iterator iter = begin(); iter != end(); ++iter)
         {
-            if (rhs.found(iter.key()) && erase(iter))
+            count++;
-            {
-                count++;
-            }
         }
     }
 
@@ -490,7 +436,7 @@ Foam::label Foam::HashTable<T, Key, Hash>::erase
 template<class T, class Key, class Hash>
 void Foam::HashTable<T, Key, Hash>::resize(const label sz)
 {
-    label newSize = canonicalSize(sz);
+    label newSize = HashTableCore::canonicalSize(sz);
 
     if (newSize == tableSize_)
     {
@@ -505,22 +451,22 @@ void Foam::HashTable<T, Key, Hash>::resize(const label sz)
         return;
     }
 
-    HashTable<T, Key, Hash>* newTable = new HashTable<T, Key, Hash>(newSize);
+    HashTable<T, Key, Hash>* tmpTable = new HashTable<T, Key, Hash>(newSize);
 
     for (const_iterator iter = cbegin(); iter != cend(); ++iter)
     {
-        newTable->insert(iter.key(), *iter);
+        tmpTable->insert(iter.key(), *iter);
     }
 
-    label oldTableSize = tableSize_;
+    label oldSize = tableSize_;
-    tableSize_ = newTable->tableSize_;
+    tableSize_ = tmpTable->tableSize_;
-    newTable->tableSize_ = oldTableSize;
+    tmpTable->tableSize_ = oldSize;
 
     hashedEntry** oldTable = table_;
-    table_ = newTable->table_;
+    table_ = tmpTable->table_;
-    newTable->table_ = oldTable;
+    tmpTable->table_ = oldTable;
 
-    delete newTable;
+    delete tmpTable;
 }
 
 
@@ -556,6 +502,19 @@ void Foam::HashTable<T, Key, Hash>::clearStorage()
 }
 
 
+template<class T, class Key, class Hash>
+void Foam::HashTable<T, Key, Hash>::shrink()
+{
+    const label newSize = HashTableCore::canonicalSize(nElmts_);
+
+    if (newSize < tableSize_)
+    {
+        // avoid having the table disappear on us
+        resize(newSize ? newSize : 2);
+    }
+}
+
+
 template<class T, class Key, class Hash>
 void Foam::HashTable<T, Key, Hash>::transfer(HashTable<T, Key, Hash>& ht)
 {
@@ -619,18 +578,12 @@ bool Foam::HashTable<T, Key, Hash>::operator==
     const HashTable<T, Key, Hash>& rhs
 ) const
 {
-    // Are all my elements in rhs?
+    // sizes (number of keys) must match
-    for (const_iterator iter = cbegin(); iter != cend(); ++iter)
+    if (size() != rhs.size())
     {
-        const_iterator fnd = rhs.find(iter.key());
+        return false;
-
-        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());
@@ -640,6 +593,7 @@ bool Foam::HashTable<T, Key, Hash>::operator==
             return false;
         }
     }
+
     return true;
 }
 

src/OpenFOAM/containers/HashTables/HashTable/HashTable.H

@@ -71,23 +71,60 @@ Ostream& operator<<(Ostream&, const HashTable<T, Key, Hash>&);
 
 
 /*---------------------------------------------------------------------------*\
-                        Class HashTableName Declaration
+                         Class HashTableCore Declaration
 \*---------------------------------------------------------------------------*/
 
-TemplateName(HashTable);
+//- Template-invariant bits for HashTable
+struct HashTableCore
+{
+    //- Return a canonical (power-of-two) size
+    static label canonicalSize(const label);
+
+    //- Maximum allowable table size
+    static const label maxTableSize;
+
+    //- Construct null
+    HashTableCore()
+    {}
+
+    //- Define template name and debug
+    ClassName("HashTable");
+
+    //- A zero-sized end iterator
+    struct iteratorEnd
+    {
+        //- Construct null
+        iteratorEnd()
+        {}
+    };
+
+    //- iteratorEnd set to beyond the end of any HashTable
+    inline static iteratorEnd cend()
+    {
+        return iteratorEnd();
+    }
+
+    //- iteratorEnd set to beyond the end of any HashTable
+    inline static iteratorEnd end()
+    {
+        return iteratorEnd();
+    }
+
+};
 
 
 /*---------------------------------------------------------------------------*\
-                          Class HashTable Declaration
+                           Class HashTable Declaration
 \*---------------------------------------------------------------------------*/
 
 template<class T, class Key=word, class Hash=string::hash>
 class HashTable
 :
-    public HashTableName
+    public HashTableCore
 {
     // Private data type for table entries
 
+        //- Structure to hold a hashed entry with SLList for collisions
         struct hashedEntry
         {
             //- The lookup key
@@ -99,18 +136,15 @@ class HashTable
             //- The data object
             T obj_;
 
-            //- Constructors
+            //- Construct from key, next pointer and object
+            inline hashedEntry(const Key&, hashedEntry* next, const T&);
 
-                //- Construct given key, next pointer and object
+        private:
-                inline hashedEntry
+            //- Disallow default bitwise copy construct
-                (
+            hashedEntry(const hashedEntry&);
-                    const Key&,
-                    hashedEntry* next,
-                    const T& newEntry
-                );
 
-                //- Dissallow construction as copy
+            //- Disallow default bitwise assignment
-                hashedEntry(const hashedEntry&);
+            void operator=(const hashedEntry&);
         };
 
 
@@ -119,7 +153,7 @@ class HashTable
         //- The current number of elements in table
         label nElmts_;
 
-        //- Number of primary entries allocated in table (not necessarily used)
+        //- Number of primary entries allocated in table
         label tableSize_;
 
         //- The table of primary entries
@@ -140,17 +174,23 @@ class HashTable
 
 public:
 
+    // Forward declaration of iterators
+
+        class iteratorBase;
+        class iterator;
+        class const_iterator;
+
         //- Declare friendship with the HashPtrTable class
         template<class T2, class Key2, class Hash2>
         friend class HashPtrTable;
 
+        //- Declare friendship with the iteratorBase
+        friend class iteratorBase;
 
-    // Forward declaration of STL iterators
+        //- Declare friendship with the iterator
-
-        class iterator;
         friend class iterator;
 
-        class const_iterator;
+        //- Declare friendship with the const_iterator
         friend class const_iterator;
 
 
@@ -178,7 +218,10 @@ public:
 
         // Access
 
-            //- Return number of elements in table.
+            //- The size of the underlying table
+            inline label capacity() const;
+
+            //- Return number of elements in table
             inline label size() const;
 
             //- Return true if the hash table is empty
@@ -212,10 +255,11 @@ public:
             //- Assign a new hashedEntry, overwriting existing entries
             inline bool set(const Key&, const T& newElmt);
 
-            //- Erase an hashedEntry specified by given iterator
+            //- Erase a hashedEntry specified by given iterator
+            //  This invalidates the iterator until the next operator++
             bool erase(const iterator&);
 
-            //- Erase an hashedEntry specified by given key if in table
+            //- Erase a hashedEntry specified by the given key
             bool erase(const Key&);
 
             //- Remove entries given by the listed keys from this HashTable
@@ -224,10 +268,10 @@ public:
 
             //- Remove entries given by the given keys from this HashTable
             //  Return the number of elements removed.
-            //  The parameter HashTable needs the same type of keys, but
+            //  The parameter HashTable needs the same type of key, but the
-            //  but the type of values held is arbitrary.
+            //  type of values held and the hashing function are arbitrary.
-            template<class AnyType>
+            template<class AnyType, class AnyHash>
-            label erase(const HashTable<AnyType, Key, Hash>&);
+            label erase(const HashTable<AnyType, Key, AnyHash>&);
 
             //- Resize the hash table for efficiency
             void resize(const label newSize);
@@ -239,31 +283,33 @@ public:
             //  Equivalent to clear() followed by resize(0)
             void clearStorage();
 
+            //- Shrink the allocated table to approx. twice number of elements
+            void shrink();
+
             //- Transfer the contents of the argument table into this table
             //  and annull the argument table.
             void transfer(HashTable<T, Key, Hash>&);
 
             //- Transfer contents to the Xfer container
-            inline Xfer<HashTable<T, Key, Hash> > xfer();
+            inline Xfer< HashTable<T, Key, Hash> > xfer();
 
 
     // Member Operators
 
-        //- Find and return an hashedEntry
+        //- Find and return a hashedEntry
         inline T& operator[](const Key&);
 
-        //- Find and return an hashedEntry
+        //- Find and return a hashedEntry
         inline const T& operator[](const Key&) const;
 
-        //- Find and return an hashedEntry, create it null if not present.
+        //- Find and return a hashedEntry, create it null if not present
         inline T& operator()(const Key&);
 
         //- Assignment
         void operator=(const HashTable<T, Key, Hash>&);
 
-        //- Equality. Two hash tables are equal if all contents of first are
+        //- Equality. Hash tables are equal if the keys and values are equal.
-        //  also in second and vice versa. So does not depend on table size or
+        //  Independent of table storage size and table order.
-        //  order!
         bool operator==(const HashTable<T, Key, Hash>&) const;
 
         //- The opposite of the equality operation. Takes linear time.
@@ -289,134 +335,193 @@ public:
         typedef label size_type;
 
 
-    // STL iterator
+    // Iterators and helpers
 
-        //- An STL-conforming iterator
+        //- The iterator base for HashTable
-        class iterator
+        //  Note: data and functions are protected, to allow reuse by iterator
+        //  and prevent most external usage.
+        //  iterator and const_iterator have the same size, allowing
+        //  us to reinterpret_cast between them (if desired)
+        class iteratorBase
         {
-            friend class HashTable;
+            // Private Data
-            friend class const_iterator;
 
-            // Private data
+                //- Pointer to the HashTable for which this is an iterator
-
+                //  This also lets us use the default bitwise copy/assignment
-                //- Reference to the HashTable this is an iterator for
+                HashTable<T, Key, Hash>* hashTable_;
-                HashTable<T, Key, Hash>& hashTable_;
 
                 //- Current element
-                hashedEntry* elmtPtr_;
+                hashedEntry* entryPtr_;
 
                 //- Current hash index
                 label hashIndex_;
 
+        protected:
+
+            // Protected Member Functions
+
+            // Constructors
+
+                //- Construct null - equivalent to an 'end' position
+                inline iteratorBase();
+
+                //- Construct from hash table, moving to its 'begin' position
+                inline explicit iteratorBase
+                (
+                    const HashTable<T, Key, Hash>* curHashTable
+                );
+
+                //- Construct from hash table, element and hash index
+                inline explicit iteratorBase
+                (
+                    const HashTable<T, Key, Hash>* curHashTable,
+                    const hashedEntry* elmt,
+                    const label hashIndex
+                );
+
+
+                //- Increment to the next position
+                inline void increment();
+
+                //- Erase the HashTable element at the current position
+                bool erase();
+
+                //- Return non-const access to referenced object
+                inline T& object();
+
+                //- Return const access to referenced object
+                inline const T& cobject() const;
+
+        public:
+
+            // Member operators
+
+                // Access
+
+                //- Return the Key corresponding to the iterator
+                inline const Key& key() const;
+
+                //- Compare hashedEntry element pointers
+                inline bool operator==(const iteratorBase&) const;
+                inline bool operator!=(const iteratorBase&) const;
+
+                //- Compare hashedEntry to iteratorEnd pointers
+                inline bool operator==(const iteratorEnd& unused) const;
+                inline bool operator!=(const iteratorEnd& unused) const;
+        };
+
+
+        //- An STL-conforming iterator
+        class iterator
+        :
+            public iteratorBase
+        {
+            friend class HashTable;
+
+            // Private Member Functions
+
+                //- Construct from hash table, moving to its 'begin' position
+                inline explicit iterator
+                (
+                    HashTable<T, Key, Hash>* curHashTable
+                );
+
+                //- Construct from hash table, element and hash index
+                inline explicit iterator
+                (
+                    HashTable<T, Key, Hash>* curHashTable,
+                    hashedEntry* elmt,
+                    const label hashIndex
+                );
+
         public:
 
             // Constructors
 
-                //- Construct from hash table, element and hash index
+                //- Construct null (end iterator)
-                inline iterator
+                inline iterator();
-                (
+
-                    HashTable<T, Key, Hash>& curHashTable,
+                //- Construct end iterator
-                    hashedEntry* elmt,
+                inline iterator(const iteratorEnd& unused);
-                    label hashIndex
-                );
 
             // Member operators
 
-                inline void operator=(const iterator&);
+                //- Conversion to a const_iterator
+                inline operator const_iterator() const;
 
-                inline bool operator==(const iterator&) const;
+                // Access
-                inline bool operator!=(const iterator&) const;
-
-                inline bool operator==(const const_iterator&) const;
-                inline bool operator!=(const const_iterator&) const;
 
+                //- Return referenced hash value
                 inline T& operator*();
                 inline T& operator()();
 
+                //- Return referenced hash value
                 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 HashTable
         inline iterator begin();
 
-        //- iterator set to beyond the end of the HashTable
-        inline const iterator& end();
-
 
     // STL const_iterator
 
         //- An STL-conforming const_iterator
         class const_iterator
+        :
+            public iteratorBase
         {
-            friend class iterator;
+            friend class HashTable;
 
-            // Private data
+            // Private Member Functions
 
-                //- Reference to the HashTable this is an iterator for
+                //- Construct from hash table, moving to its 'begin' position
-                const HashTable<T, Key, Hash>& hashTable_;
+                inline explicit const_iterator
-
+                (
-                //- Current element
+                    const HashTable<T, Key, Hash>* curHashTable
-                const hashedEntry* elmtPtr_;
+                );
-
-                //- Current hash index
-                label hashIndex_;
 
+                //- Construct from hash table, element and hash index
+                inline explicit const_iterator
+                (
+                    const HashTable<T, Key, Hash>* curHashTable,
+                    const hashedEntry* elmt,
+                    const label hashIndex
+                );
 
         public:
 
             // Constructors
 
-                //- Construct from hash table, element and hash index
+                //- Construct null (end iterator)
-                inline const_iterator
+                inline const_iterator();
-                (
-                    const HashTable<T, Key, Hash>& curHashTable,
-                    const hashedEntry* elmt,
-                    label hashIndex
-                );
-
-                //- Construct from the non-const iterator
-                inline const_iterator(const iterator&);
 
+                //- Construct end iterator
+                inline const_iterator(const iteratorEnd& unused);
 
             // Member operators
 
-                inline void operator=(const const_iterator&);
+                // Access
-
-                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;
 
+                //- Return referenced hash value
                 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 HashTable
         inline const_iterator cbegin() const;
 
-        //- const_iterator set to beyond the end of the HashTable
-        inline const const_iterator& cend() const;
-
         //- const_iterator set to the beginning of the HashTable
         inline const_iterator begin() const;
 
-        //- const_iterator set to beyond the end of the HashTable
-        inline const const_iterator& end() const;
-
 
     // IOstream Operator
 
@@ -432,14 +537,6 @@ public:
             const HashTable<T, Key, Hash>&
         );
 
-
-private:
-
-        //- iterator returned by end()
-        iterator endIter_;
-
-        //- const_iterator returned by end()
-        const_iterator endConstIter_;
 };
 
 

src/OpenFOAM/containers/HashTables/HashTable/HashTableCore.C

@@ -28,6 +28,40 @@ License
 
 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
 
-defineTypeNameAndDebug(Foam::HashTableName, 0);
+defineTypeNameAndDebug(Foam::HashTableCore, 0);
+
+const Foam::label Foam::HashTableCore::maxTableSize
+(
+    Foam::HashTableCore::canonicalSize
+    (
+        Foam::labelMax/2
+    )
+);
+
+// * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * * //
+
+Foam::label Foam::HashTableCore::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;
+}
+
 
 // ************************************************************************* //

src/OpenFOAM/containers/HashTables/HashTable/HashTableI.H

@@ -33,12 +33,12 @@ inline Foam::HashTable<T, Key, Hash>::hashedEntry::hashedEntry
 (
     const Key& key,
     hashedEntry* next,
-    const T& newEntry
+    const T& obj
 )
 :
     key_(key),
     next_(next),
-    obj_(newEntry)
+    obj_(obj)
 {}
 
 
@@ -55,6 +55,13 @@ Foam::HashTable<T, Key, Hash>::hashKeyIndex(const Key& key) const
 
 // * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
 
+template<class T, class Key, class Hash>
+inline Foam::label Foam::HashTable<T, Key, Hash>::capacity() const
+{
+    return tableSize_;
+}
+
+
 template<class T, class Key, class Hash>
 inline Foam::label Foam::HashTable<T, Key, Hash>::size() const
 {
@@ -152,70 +159,218 @@ inline T& Foam::HashTable<T, Key, Hash>::operator()(const Key& key)
 }
 
 
-// * * * * * * * * * * * * * * * * STL iterator  * * * * * * * * * * * * * * //
+// * * * * * * * * * * * * * * * iterator base * * * * * * * * * * * * * * * //
 
 template<class T, class Key, class Hash>
-inline Foam::HashTable<T, Key, Hash>::iterator::iterator
+inline Foam::HashTable<T, Key, Hash>::iteratorBase::iteratorBase()
+:
+    hashTable_(0),
+    entryPtr_(0),
+    hashIndex_(0)
+{}
+
+
+template<class T, class Key, class Hash>
+inline Foam::HashTable<T, Key, Hash>::iteratorBase::iteratorBase
 (
-    HashTable<T, Key, Hash>& hashTbl,
+    const HashTable<T, Key, Hash>* hashTbl
-    hashedEntry* elmt,
-    label hashIndex
 )
 :
-    hashTable_(hashTbl),
+    hashTable_(const_cast<HashTable<T, Key, Hash>*>(hashTbl)),
-    elmtPtr_(elmt),
+    entryPtr_(0),
+    hashIndex_(0)
+{
+    if (hashTable_->nElmts_ && hashTable_->table_)
+    {
+        // find first non-NULL table entry
+        while
+        (
+            !(entryPtr_ = hashTable_->table_[hashIndex_])
+         && ++hashIndex_ < hashTable_->tableSize_
+        )
+        {}
+
+        if (hashIndex_ >= hashTable_->tableSize_)
+        {
+            // make into an end iterator
+            entryPtr_ = 0;
+            hashIndex_ = 0;
+        }
+    }
+}
+
+
+template<class T, class Key, class Hash>
+inline Foam::HashTable<T, Key, Hash>::iteratorBase::iteratorBase
+(
+    const HashTable<T, Key, Hash>* hashTbl,
+    const hashedEntry* elmt,
+    const label hashIndex
+)
+:
+    hashTable_(const_cast<HashTable<T, Key, Hash>*>(hashTbl)),
+    entryPtr_(const_cast<hashedEntry*>(elmt)),
     hashIndex_(hashIndex)
 {}
 
 
 template<class T, class Key, class Hash>
-inline void Foam::HashTable<T, Key, Hash>::iterator::operator=
+inline void
+Foam::HashTable<T, Key, Hash>::iteratorBase::increment()
+{
+    // A negative index is a special value from erase
+    if (hashIndex_ < 0)
+    {
+        // the markPos='-curPos-1', but we wish to continue at 'curPos-1'
+        // thus use '-(markPos+1) -1'
+        hashIndex_ = -(hashIndex_+1) - 1;
+    }
+    else if (entryPtr_)
+    {
+        if (entryPtr_->next_)
+        {
+            // Move to next element on the SLList
+            entryPtr_ = entryPtr_->next_;
+            return;
+        }
+    }
+    // else
+    // {
+    //     // if we reach here (entryPtr_ is NULL) it is already at the end()
+    //     // we should probably stop
+    // }
+
+
+    // Step to the next table entry
+    while
+    (
+        ++hashIndex_ < hashTable_->tableSize_
+     && !(entryPtr_ = hashTable_->table_[hashIndex_])
+    )
+    {}
+
+    if (hashIndex_ >= hashTable_->tableSize_)
+    {
+        // make into an end iterator
+        entryPtr_ = 0;
+        hashIndex_ = 0;
+    }
+}
+
+
+template<class T, class Key, class Hash>
+inline
+const Key& Foam::HashTable<T, Key, Hash>::iteratorBase::key() const
+{
+    return entryPtr_->key_;
+}
+
+
+template<class T, class Key, class Hash>
+inline T&
+Foam::HashTable<T, Key, Hash>::iteratorBase::object()
+{
+    return entryPtr_->obj_;
+}
+
+
+template<class T, class Key, class Hash>
+inline const T&
+Foam::HashTable<T, Key, Hash>::iteratorBase::cobject() const
+{
+    return entryPtr_->obj_;
+}
+
+
+template<class T, class Key, class Hash>
+inline bool Foam::HashTable<T, Key, Hash>::iteratorBase::operator==
 (
-    const iterator& iter
+    const iteratorBase& iter
+) const
+{
+    return entryPtr_ == iter.entryPtr_;
+}
+
+
+template<class T, class Key, class Hash>
+inline bool Foam::HashTable<T, Key, Hash>::iteratorBase::operator!=
+(
+    const iteratorBase& iter
+) const
+{
+    return entryPtr_ != iter.entryPtr_;
+}
+
+
+template<class T, class Key, class Hash>
+inline bool Foam::HashTable<T, Key, Hash>::iteratorBase::operator==
+(
+    const iteratorEnd&
+) const
+{
+    return !entryPtr_;
+}
+
+
+template<class T, class Key, class Hash>
+inline bool Foam::HashTable<T, Key, Hash>::iteratorBase::operator!=
+(
+    const iteratorEnd&
+) const
+{
+    return entryPtr_;
+}
+
+
+// * * * * * * * * * * * * * * * * STL iterator  * * * * * * * * * * * * * * //
+
+template<class T, class Key, class Hash>
+inline Foam::HashTable<T, Key, Hash>::iterator::iterator()
+:
+    iteratorBase()
+{}
+
+
+template<class T, class Key, class Hash>
+inline Foam::HashTable<T, Key, Hash>::iterator::iterator
+(
+    const iteratorEnd&
 )
-{
+:
-    elmtPtr_ = iter.elmtPtr_;
+    iteratorBase()
-    hashIndex_ = iter.hashIndex_;
+{}
-}
 
 
 template<class T, class Key, class Hash>
-inline bool Foam::HashTable<T, Key, Hash>::iterator::operator==
+inline Foam::HashTable<T, Key, Hash>::iterator::iterator
 (
-    const iterator& iter
+    HashTable<T, Key, Hash>* hashTbl
-) const
+)
-{
+:
-    return elmtPtr_ == iter.elmtPtr_;
+    iteratorBase(hashTbl)
-}
+{}
 
 
 template<class T, class Key, class Hash>
-inline bool Foam::HashTable<T, Key, Hash>::iterator::operator!=
+inline Foam::HashTable<T, Key, Hash>::iterator::iterator
 (
-    const iterator& iter
+    HashTable<T, Key, Hash>* hashTbl,
-) const
+    hashedEntry* elmt,
-{
+    const label hashIndex
-    return elmtPtr_ != iter.elmtPtr_;
+)
-}
+:
+    iteratorBase(hashTbl, elmt, hashIndex)
+{}
 
 
 template<class T, class Key, class Hash>
-inline bool Foam::HashTable<T, Key, Hash>::iterator::operator==
+inline Foam::HashTable<T, Key, Hash>::iterator::operator
-(
+typename Foam::HashTable<T, Key, Hash>::const_iterator() const
-    const const_iterator& iter
-) const
 {
-    return elmtPtr_ == iter.elmtPtr_;
+    return *reinterpret_cast
-}
+    <
-
+        const typename Foam::HashTable<T, Key, Hash>::const_iterator*
-
+    >(this);
-template<class T, class Key, class Hash>
-inline bool Foam::HashTable<T, Key, Hash>::iterator::operator!=
-(
-    const const_iterator& iter
-) const
-{
-    return elmtPtr_ != iter.elmtPtr_;
 }
 
 
@@ -223,7 +378,7 @@ template<class T, class Key, class Hash>
 inline T&
 Foam::HashTable<T, Key, Hash>::iterator::operator*()
 {
-    return elmtPtr_->obj_;
+    return this->object();
 }
 
 
@@ -231,7 +386,7 @@ template<class T, class Key, class Hash>
 inline T&
 Foam::HashTable<T, Key, Hash>::iterator::operator()()
 {
-    return elmtPtr_->obj_;
+    return this->object();
 }
 
 
@@ -239,7 +394,7 @@ template<class T, class Key, class Hash>
 inline const T&
 Foam::HashTable<T, Key, Hash>::iterator::operator*() const
 {
-    return elmtPtr_->obj_;
+    return this->cobject();
 }
 
 
@@ -247,7 +402,7 @@ template<class T, class Key, class Hash>
 inline const T&
 Foam::HashTable<T, Key, Hash>::iterator::operator()() const
 {
-    return elmtPtr_->obj_;
+    return this->cobject();
 }
 
 
@@ -256,53 +411,18 @@ inline
 typename Foam::HashTable<T, Key, Hash>::iterator&
 Foam::HashTable<T, Key, Hash>::iterator::operator++()
 {
-    // Check for special value from erase. (sets hashIndex to -1)
+    this->increment();
-    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::HashTable<T, Key, Hash>::iterator
-Foam::HashTable<T, Key, Hash>::iterator::operator++
+Foam::HashTable<T, Key, Hash>::iterator::operator++(int)
-(
-    int
-)
 {
-    iterator tmp = *this;
+    iterator old = *this;
-    ++*this;
+    this->increment();
-    return tmp;
+    return old;
-}
-
-
-template<class T, class Key, class Hash>
-inline
-const Key& Foam::HashTable<T, Key, Hash>::iterator::key() const
-{
-    return elmtPtr_->key_;
 }
 
 
@@ -310,135 +430,64 @@ template<class T, class Key, class Hash>
 inline typename Foam::HashTable<T, Key, Hash>::iterator
 Foam::HashTable<T, Key, Hash>::begin()
 {
-    label i = 0;
+    return iterator(this);
-
-    if (nElmts_)
-    {
-        while (table_ && !table_[i] && ++i < tableSize_)
-        {}
-    }
-    else
-    {
-        i = tableSize_;
-    }
-
-    if (i == tableSize_)
-    {
-#       ifdef FULLDEBUG
-        if (debug)
-        {
-            Info<< "HashTable is empty\n";
-        }
-#       endif
-
-        return HashTable<T, Key, Hash>::endIter_;
-    }
-    else
-    {
-        return iterator(*this, table_[i], i);
-    }
-}
-
-
-template<class T, class Key, class Hash>
-inline const typename Foam::HashTable<T, Key, Hash>::iterator&
-Foam::HashTable<T, Key, Hash>::end()
-{
-    return HashTable<T, Key, Hash>::endIter_;
 }
 
 
 // * * * * * * * * * * * * * * * STL const_iterator * * * * * * * * * * * * * //
 
+template<class T, class Key, class Hash>
+inline Foam::HashTable<T, Key, Hash>::const_iterator::const_iterator()
+:
+    iteratorBase()
+{}
+
+
 template<class T, class Key, class Hash>
 inline Foam::HashTable<T, Key, Hash>::const_iterator::const_iterator
 (
-    const HashTable<T, Key, Hash>& hashTbl,
+    const iteratorEnd&
+)
+:
+    iteratorBase()
+{}
+
+
+template<class T, class Key, class Hash>
+inline Foam::HashTable<T, Key, Hash>::const_iterator::const_iterator
+(
+    const HashTable<T, Key, Hash>* hashTbl
+)
+:
+    iteratorBase(hashTbl)
+{}
+
+
+template<class T, class Key, class Hash>
+inline Foam::HashTable<T, Key, Hash>::const_iterator::const_iterator
+(
+    const HashTable<T, Key, Hash>* hashTbl,
     const hashedEntry* elmt,
-    label hashIndex
+    const label hashIndex
 )
 :
-    hashTable_(hashTbl),
+    iteratorBase(hashTbl, elmt, hashIndex)
-    elmtPtr_(elmt),
-    hashIndex_(hashIndex)
 {}
 
 
-template<class T, class Key, class Hash>
-inline Foam::HashTable<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::HashTable<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::HashTable<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::HashTable<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::HashTable<T, Key, Hash>::const_iterator::operator==
-(
-    const iterator& iter
-) const
-{
-    return elmtPtr_ == iter.elmtPtr_;
-}
-
-
-template<class T, class Key, class Hash>
-inline bool Foam::HashTable<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::HashTable<T, Key, Hash>::const_iterator::operator*() const
 {
-    return elmtPtr_->obj_;
+    return this->cobject();
 }
 
+
 template<class T, class Key, class Hash>
 inline const T&
 Foam::HashTable<T, Key, Hash>::const_iterator::operator()() const
 {
-    return elmtPtr_->obj_;
+    return this->cobject();
 }
 
 
@@ -447,43 +496,18 @@ inline
 typename Foam::HashTable<T, Key, Hash>::const_iterator&
 Foam::HashTable<T, Key, Hash>::const_iterator::operator++()
 {
-    if
+    this->increment();
-    (
-        !(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::HashTable<T, Key, Hash>::const_iterator
-Foam::HashTable<T, Key, Hash>::const_iterator::operator++
+Foam::HashTable<T, Key, Hash>::const_iterator::operator++(int)
-(
-    int
-)
 {
-    const_iterator tmp = *this;
+    const_iterator old = *this;
-    ++*this;
+    this->increment();
-    return tmp;
+    return old;
-}
-
-
-template<class T, class Key, class Hash>
-inline
-const Key& Foam::HashTable<T, Key, Hash>::const_iterator::key() const
-{
-    return elmtPtr_->key_;
 }
 
 
@@ -491,41 +515,7 @@ template<class T, class Key, class Hash>
 inline typename Foam::HashTable<T, Key, Hash>::const_iterator
 Foam::HashTable<T, Key, Hash>::cbegin() const
 {
-    label i = 0;
+    return const_iterator(this);
-
-    if (nElmts_)
-    {
-        while (table_ && !table_[i] && ++i < tableSize_)
-        {}
-    }
-    else
-    {
-        i = tableSize_;
-    }
-
-    if (i == tableSize_)
-    {
-#       ifdef FULLDEBUG
-        if (debug)
-        {
-            Info<< "HashTable is empty\n";
-        }
-#       endif
-
-        return HashTable<T, Key, Hash>::endConstIter_;
-    }
-    else
-    {
-        return const_iterator(*this, table_[i], i);
-    }
-}
-
-
-template<class T, class Key, class Hash>
-inline const typename Foam::HashTable<T, Key, Hash>::const_iterator&
-Foam::HashTable<T, Key, Hash>::cend() const
-{
-    return HashTable<T, Key, Hash>::endConstIter_;
 }
 
 
@@ -537,12 +527,4 @@ Foam::HashTable<T, Key, Hash>::begin() const
 }
 
 
-template<class T, class Key, class Hash>
-inline const typename Foam::HashTable<T, Key, Hash>::const_iterator&
-Foam::HashTable<T, Key, Hash>::end() const
-{
-    return HashTable<T, Key, Hash>::endConstIter_;
-}
-
-
 // ************************************************************************* //

src/OpenFOAM/containers/HashTables/HashTable/HashTableIO.C

@@ -33,16 +33,19 @@ License
 template<class T, class Key, class Hash>
 Foam::HashTable<T, Key, Hash>::HashTable(Istream& is, const label size)
 :
-    HashTableName(),
+    HashTableCore(),
     nElmts_(0),
-    tableSize_(canonicalSize(size)),
+    tableSize_(HashTableCore::canonicalSize(size)),
-    table_(new hashedEntry*[tableSize_]),
+    table_(NULL)
-    endIter_(*this, NULL, 0),
-    endConstIter_(*this, NULL, 0)
 {
-    for (label hashIdx = 0; hashIdx < tableSize_; hashIdx++)
+    if (tableSize_)
     {
-        table_[hashIdx] = 0;
+        table_ = new hashedEntry*[tableSize_];
+
+        for (label hashIdx = 0; hashIdx < tableSize_; hashIdx++)
+        {
+            table_[hashIdx] = 0;
+        }
     }
 
     operator>>(is, *this);

src/OpenFOAM/containers/HashTables/StaticHashTable/StaticHashTable.C

@@ -33,8 +33,7 @@ License
 
 // * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * * //
 
-template<class T, class Key, class Hash>
+Foam::label Foam::StaticHashTableCore::canonicalSize(const label size)
-Foam::label Foam::StaticHashTable<T, Key, Hash>::canonicalSize(const label size)
 {
     if (size < 1)
     {
@@ -64,8 +63,8 @@ Foam::label Foam::StaticHashTable<T, Key, Hash>::canonicalSize(const label size)
 template<class T, class Key, class Hash>
 Foam::StaticHashTable<T, Key, Hash>::StaticHashTable(const label size)
 :
-    StaticHashTableName(),
+    StaticHashTableCore(),
-    keys_(canonicalSize(size)),
+    keys_(StaticHashTableCore::canonicalSize(size)),
     objects_(keys_.size()),
     nElmts_(0),
     endIter_(*this, keys_.size(), 0),
@@ -89,7 +88,7 @@ Foam::StaticHashTable<T, Key, Hash>::StaticHashTable
     const StaticHashTable<T, Key, Hash>& ht
 )
 :
-    StaticHashTableName(),
+    StaticHashTableCore(),
     keys_(ht.keys_),
     objects_(ht.objects_),
     nElmts_(ht.nElmts_),
@@ -105,7 +104,7 @@ Foam::StaticHashTable<T, Key, Hash>::StaticHashTable
     const Xfer< StaticHashTable<T, Key, Hash> >& ht
 )
 :
-    StaticHashTableName(),
+    StaticHashTableCore(),
     keys_(0),
     objects_(0),
     nElmts_(0),
@@ -224,15 +223,15 @@ Foam::StaticHashTable<T, Key, Hash>::find
 template<class T, class Key, class Hash>
 Foam::List<Key> Foam::StaticHashTable<T, Key, Hash>::toc() const
 {
-    List<Key> tofc(nElmts_);
+    List<Key> keys(nElmts_);
-    label i = 0;
+    label keyI = 0;
 
     for (const_iterator iter = cbegin(); iter != cend(); ++iter)
     {
-        tofc[i++] = iter.key();
+        keys[keyI++] = iter.key();
     }
 
-    return tofc;
+    return keys;
 }
 
 
@@ -319,24 +318,9 @@ bool Foam::StaticHashTable<T, Key, Hash>::erase(const iterator& cit)
         if (it.elemIndex_ < 0)
         {
             // No previous element in the local list
-
+            // Mark with as special value (see notes in HashTable)
-            // Search back for previous non-zero table entry
+            it.hashIndex_ = -it.hashIndex_ - 1;
-            while (--it.hashIndex_ >= 0 && !objects_[it.hashIndex_].size())
+            it.elemIndex_ = 0;
-            {}
-
-            if (it.hashIndex_ >= 0)
-            {
-                // The last element in the local list
-                it.elemIndex_ = objects_[it.hashIndex_].size() - 1;
-            }
-            else
-            {
-                // No previous found. Mark with special value which is
-                // - not end()
-                // - handled by operator++
-                it.hashIndex_ = -1;
-                it.elemIndex_ = 0;
-            }
         }
 
         nElmts_--;
@@ -407,8 +391,8 @@ Foam::label Foam::StaticHashTable<T, Key, Hash>::erase
 template<class T, class Key, class Hash>
 void Foam::StaticHashTable<T, Key, Hash>::resize(const label sz)
 {
-    label newSize = canonicalSize(sz);
+    label newSize = StaticHashTableCore::canonicalSize(sz);
-    
+
     if (newSize == keys_.size())
     {
 #       ifdef FULLDEBUG
@@ -543,18 +527,8 @@ bool Foam::StaticHashTable<T, Key, Hash>::operator==
     const StaticHashTable<T, Key, Hash>& rhs
 ) const
 {
-    // Are all my elements in rhs?
+    // sizes (number of keys) must match
-    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());
@@ -564,6 +538,7 @@ bool Foam::StaticHashTable<T, Key, Hash>::operator==
             return false;
         }
     }
+
     return true;
 }
 

src/OpenFOAM/containers/HashTables/StaticHashTable/StaticHashTable.H

@@ -76,7 +76,33 @@ template<class T, class Key, class Hash> Ostream& operator<<
                      Class StaticHashTableName Declaration
 \*---------------------------------------------------------------------------*/
 
-TemplateName(StaticHashTable);
+/*---------------------------------------------------------------------------*\
+                     Class StaticHashTableCore Declaration
+\*---------------------------------------------------------------------------*/
+
+//- Template-invariant bits for StaticHashTable
+struct StaticHashTableCore
+{
+    //- Return a canonical (power-of-two) size
+    static label canonicalSize(const label);
+
+    //- Construct null
+    StaticHashTableCore()
+    {}
+
+    //- Define template name and debug
+    ClassName("StaticHashTable");
+
+    //- A zero-sized end iterator
+    struct iteratorEnd
+    {
+        //- Construct null
+        iteratorEnd()
+        {}
+    };
+
+};
+
 
 
 /*---------------------------------------------------------------------------*\
@@ -86,7 +112,7 @@ TemplateName(StaticHashTable);
 template<class T, class Key=word, class Hash=string::hash>
 class StaticHashTable
 :
-    public StaticHashTableName
+    public StaticHashTableCore
 {
     // Private data type for table entries
 

src/OpenFOAM/containers/HashTables/StaticHashTable/StaticHashTableCore.C

@@ -28,6 +28,6 @@ License
 
 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
 
-defineTypeNameAndDebug(Foam::StaticHashTableName, 0);
+defineTypeNameAndDebug(Foam::StaticHashTableCore, 0);
 
 // ************************************************************************* //