exaFOAM/foam-extend4.1-coherent-io
Archived
1
1
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

Merge update

Browse source
This commit is contained in:
Hrvoje Jasak 2010-08-24 16:19:39 +01:00
parent 288efa21ab
commit 54c7d7fb19
2072 changed files with 122654 additions and 35119 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

5
doc/Allwmake
View file

@ -1,8 +1,11 @@
#!/bin/sh #!/bin/sh
cd ${0%/*} || exit 1 # run from this directory
set -x set -x
chmod a+rX $WM_PROJECT_DIR chmod a+rX $WM_PROJECT_DIR
chmod a+rX $WM_PROJECT_DIR/doc chmod a+rX $WM_PROJECT_DIR/doc
chmod -R a+rX Doxygen chmod -R a+rX Doxygen
( cd Doxygen && ./Allwmake ) Doxygen/Allwmake
# ----------------------------------------------------------------- end-of-file

5
doc/Doxygen/Allwmake
View file

@ -1,9 +1,12 @@
#!/bin/sh #!/bin/sh
cd ${0%/*} || exit 1 # run from this directory
set -x set -x
umask 22 umask 22
rm -rf html latex man rm -rf html latex man
doxygen doxygen
# fix permissions (NB: '-X' and not '-x'!) # fix permissions (NB: '+X' and not '+x'!)
chmod -R a+rX ./ chmod -R a+rX ./
# ----------------------------------------------------------------- end-of-file

2
doc/Doxygen/Doxyfile
View file

@ -788,7 +788,7 @@ TREEVIEW_WIDTH = 250
# configuration options related to the LaTeX output # configuration options related to the LaTeX output
#--------------------------------------------------------------------------- #---------------------------------------------------------------------------
# Path for OpenFOAM LaTeX macros # Path for OpenCFD LaTeX macros
@INCLUDE_PATH = $(WM_PROJECT_DIR)/doc/Doxygen/Macros/ @INCLUDE_PATH = $(WM_PROJECT_DIR)/doc/Doxygen/Macros/

2
doc/Doxygen/FoamFooter.html
View file

@ -1,4 +1,4 @@
Copyright © 2000-2008 OpenFOAM Foundation Copyright © 2000-2009 OpenCFD Ltd
</td></tr> </td></tr>
</table> </table>
</body> </body>

26
doc/Doxygen/FoamHeader.html
View file

@ -1,7 +1,7 @@
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
"http://www.w3.org/TR/html4/loose.dtd"> "http://www.w3.org/TR/html4/loose.dtd">
<html > <html >
<head>open <head>
<title> OpenFOAM programmer's C++ documentation <title> OpenFOAM programmer's C++ documentation
</title> </title>
<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1"> <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
@ -12,8 +12,8 @@
<meta name="date" content="2007-04-12 00:02:00"> <meta name="date" content="2007-04-12 00:02:00">
<link rel="stylesheet" type="text/css" href="../Doxygen.css"> <link rel="stylesheet" type="text/css" href="../Doxygen.css">
<link rel="stylesheet" type="text/css" href="../tabs.css"> <link rel="stylesheet" type="text/css" href="../tabs.css">
<meta name="keywords" content="computational fluid dynamics, CFD, OpenFOAM, open source CFD, open source"> <meta name="keywords" content="computational fluid dynamics, CFD, OpenCFD, OpenFOAM, open source CFD, open source">
<meta name="description" content="OpenFOAM, leading open source Computational Fluid Dynamics (CFD)"> <meta name="description" content="OpenCFD Ltd, leaders in open source Computational Fluid Dynamics (CFD), the developers and maintainers of OpenFOAM: the open source CFD toolbox. We supply support and contracted developments for OpenFOAM">
</head> </head>
<body> <body>
<a id="openfoam"> </a> <a id="openfoam"> </a>
@ -40,6 +40,26 @@ horizontal-align: left; ">
<td valign=top> <td valign=top>
<table width=801 border=0 cellspacing=1 cellpadding=0 bgcolor="#ffffff"> <table width=801 border=0 cellspacing=1 cellpadding=0 bgcolor="#ffffff">
<tr> <tr>
<td class=leftmenu>&nbsp;
<a href="http://foam.sourceforge.net/doc/Doxygen/html"
class=menuLefton >Source Guide</a>
</td>
<td class=topmenu>
<a href="http://www.opencfd.co.uk/index.html"
class=menuTopoff >OpenCFD</a>
</td>
<td class=topmenu>
<a href="http://www.opencfd.co.uk/solutions/index.html"
class=menuTopoff >Solutions</a>
</td>
<td class=topmenu>
<a href="http://www.opencfd.co.uk/contact/index.html"
class=menuTopoff >Contact</a>
</td>
<td class=topmenu>
<a href="http://www.opencfd.co.uk/openfoam/index.html"
class=menuTopoff >OpenFOAM</a>
</td>
</tr> </tr>
<tr> <tr>
<td> <td>

129
doc/Doxygen/Macros/tensorOperator.sty Normal file
View file

@ -0,0 +1,129 @@
%-----------------------------------------------------------------------------
% ========= |
% \\ / F ield | OpenFOAM: The Open Source CFD Toolbox
% \\ / O peration |
% \\ / A nd | Copyright held by original author
% \\/ 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
%
% LaTeX Style file
% tensorOperator.sty
%
% Description
% Standard OpenCFD LaTeX macros for typesetting tensor algebra.
%
%------------------------------------------------------------------------------
% tensor style
% ~~~~~~~~~~~~
\renewcommand{\vec}[1] {\ensuremath{\mathbf #1}}
\newcommand{\gvec}[1] {\ensuremath{\mbox{\boldmath$\bf#1$}}}
% products
% ~~~~~~~~
\newcommand{\anyprod}{\star}
\newcommand{\cprod} {\times}
\newcommand{\dprod} {\,{\scriptscriptstyle \stackrel{\bullet}{{}}}\,}
\newcommand{\ddprod} {\,{\scriptscriptstyle \stackrel{\bullet}{\bullet}}\,}
\newcommand{\tdprod} {\,{\scriptscriptstyle \stackrel{3}{\bullet}}\,}
\newcommand{\tprod} {\,{\scriptscriptstyle \stackrel{\otimes}{{}}}\,}
% operations
% ~~~~~~~~~~
\newcommand{\adj} {\ensuremath{\operatorname{adj}}}
\newcommand{\cof} {\ensuremath{\operatorname{cof}}}
\newcommand{\diag} {\ensuremath{\operatorname{diag}}}
\newcommand{\dev} {\ensuremath{\operatorname{dev}}}
\newcommand{\Hodge} {\ensuremath{\operatorname{\stackrel{\displaystyle \ast}{}}}}
\newcommand{\hyd} {\ensuremath{\operatorname{hyd}}}
\renewcommand{\max} {\ensuremath{\operatorname{max}}}
\renewcommand{\min} {\ensuremath{\operatorname{min}}}
\newcommand{\inv} {\ensuremath{\operatorname{inv}}}
\newcommand{\sym} {\ensuremath{\operatorname{symm}}} % symm ?
\newcommand{\skw} {\ensuremath{\operatorname{skew}}} % skew already defined
\newcommand{\tr} {\ensuremath{\operatorname{tr}}}
\newcommand{\trans}[1] {\ensuremath{#1^{\operatorname{T}}}}
% alternative tensor operators for hypersonics etc.
% ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
\newcommand{\devs}[1] {\overset{\scriptscriptstyle\circ}{#1}}
%\newcommand{\trans}[1] {\ensuremath{#1^{\operatorname{T}}}}
\newcommand{\symms}[1] {\overleftrightarrow{#1}}
\newlength{\skewslength}
\newlength{\skewsheight}
\newcommand{\skews}[1]{
\settowidth{\skewslength}{#1}%
\settoheight{\skewsheight}{#1}%
\addtolength{\skewsheight}{0.4mm}%
{\overleftrightarrow{#1}\hspace{-.5\skewslength}%
\rule[\skewsheight]{.4pt}{1.4mm}
\hspace{.5\skewslength}%
}}
%\newcommand{\skew}[1] {\ensuremath{#1^{\operatorname{A}}}}
% spatial derivatives
% ~~~~~~~~~~~~~~~~~~~
\newcommand{\curl}{\ensuremath{\nabla\cprod}}
\renewcommand{\div} {\ensuremath{\nabla\dprod}}
\newcommand{\grad}{\ensuremath{\nabla}}
\newcommand{\laplacian}{\ensuremath{\nabla^{2}}}
% temporal derivatives
% ~~~~~~~~~~~~~~~~~~~~
\newcommand{\ddt}[1] {\ensuremath{\frac{\partial #1}{\partial t }}}
\newcommand{\DDt}[1] {\ensuremath{\frac{D #1}{D t}}}
\newcommand{\DpDt}[2] {\ensuremath{\frac{d_{#1} #2}{d t }}}
\newcommand{\dsdts}[1] {\ensuremath{\frac{\partial ^2 #1}{\partial t^2}}}
\newcommand{\rate}[1] {\ensuremath{\dot{#1}}}
\newcommand{\genDer}{\mathcal{L}}
% time average symbols
% ~~~~~~~~~~~~~~~~~~~~
\newcommand{\av}[1] {\ensuremath{\overline{#1}}}
\newcommand{\corrtwo}[2] {{\dwea{\dprime{#1} \dprime{#2}}}}
\newcommand{\curly}[1] {{\cal #1}}
\newcommand{\dprime}[1] {\ensuremath{{#1}^{^{\prime \prime}}}}
\newcommand{\dwea}[1] {\ensuremath{\widetilde{#1}}}
\newcommand{\dweafluc}[1] {\ensuremath{\dprime{#1}}}
\newcommand{\fluc}[1] {\ensuremath{#1^{\prime}}}
% index style
% ~~~~~~~~~~~
\newcommand{\veci}[2][i] {\ensuremath{#2_{#1}}}
\newcommand{\teni}[2][ij] {\ensuremath{#2_{#1}}}
\newcommand{\tenTi}[2][ji] {\ensuremath{#2_{#1}}}
% index operations
% ~~~~~~~~~~~~~~~~
\newcommand{\deltai}[1] {\ensuremath{\partial_{#1}}}
% Sub-subscripts
% ~~~~~~~~~~~~~~
\newcommand{\eff} {{\scriptscriptstyle e\!f\!\!f\!}}
% unknown use
% ~~~~~~~~~~~
%\font\bigtenrm=cmr12 scaled 1200
%\newcommand{\eexp}[1]{{\hbox{$\textfont1=\bigtenrm e$}}^{\raise3pt
%\hbox{$#1$}}}
% ------------------------------------------------------------------------------

BIN
doc/Guides-a4/ProgrammersGuide.pdf
View file

Binary file not shown.

BIN
doc/Guides-a4/UserGuide.pdf
View file

Binary file not shown.

BIN
doc/Guides-usletter/ProgrammersGuide.pdf Normal file
View file

Binary file not shown.

BIN
doc/Guides-usletter/UserGuide.pdf Normal file
View file

Binary file not shown.

6
src/ODE/ODE/ODE.H
View file

@ -23,7 +23,7 @@ License
Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
Class Class
ODE Foam::ODE
Description Description
Abstract base class for the ODE solvers. Abstract base class for the ODE solvers.
@ -34,7 +34,7 @@ Description
#define ODE_H #define ODE_H
#include "scalarField.H" #include "scalarField.H"
#include "Matrix.H" #include "scalarMatrices.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
@ -87,7 +87,7 @@ public:
const scalar x, const scalar x,
const scalarField& y, const scalarField& y,
scalarField& dfdx, scalarField& dfdx,
Matrix<scalar>& dfdy scalarSquareMatrix& dfdy
) const = 0; ) const = 0;
//- Update ODE after the solution, advancing by delta //- Update ODE after the solution, advancing by delta

6
src/ODE/ODESolvers/KRR4/KRR4.H
View file

@ -23,7 +23,7 @@ License
Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
Class Class
KRR4 Foam::KRR4
Description Description
Fourth-order Kaps-Rentrop scheme with adjustive time-step size Fourth-order Kaps-Rentrop scheme with adjustive time-step size
@ -63,8 +63,8 @@ class KRR4
mutable scalarField g4_; mutable scalarField g4_;
mutable scalarField yErr_; mutable scalarField yErr_;
mutable scalarField dfdx_; mutable scalarField dfdx_;
mutable Matrix<scalar> dfdy_; mutable scalarSquareMatrix dfdy_;
mutable Matrix<scalar> a_; mutable scalarSquareMatrix a_;
mutable labelList pivotIndices_; mutable labelList pivotIndices_;
static const int maxtry = 40; static const int maxtry = 40;

2
src/ODE/ODESolvers/ODESolver/ODESolver.C
View file

@ -22,8 +22,6 @@ License
along with OpenFOAM; if not, write to the Free Software Foundation, along with OpenFOAM; if not, write to the Free Software Foundation,
Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
Description
\*---------------------------------------------------------------------------*/ \*---------------------------------------------------------------------------*/
#include "ODESolver.H" #include "ODESolver.H"

3
src/ODE/ODESolvers/ODESolver/ODESolver.H
View file

@ -23,9 +23,10 @@ License
Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
Class Class
ODESolver Foam::ODESolver
Description Description
Selection for ODE solver
SourceFiles SourceFiles
ODESolver.C ODESolver.C

2
src/ODE/ODESolvers/RK/RK.H
View file

@ -23,7 +23,7 @@ License
Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
Class Class
RK Foam::RK
Description Description
Fifth-order Cash-Karp embedded Runge-Kutta scheme with error control and Fifth-order Cash-Karp embedded Runge-Kutta scheme with error control and

12
src/ODE/ODESolvers/SIBS/SIBS.H
View file

@ -33,6 +33,7 @@ Description
SourceFiles SourceFiles
SIBS.C SIBS.C
SIMPR.C SIMPR.C
polyExtrapolate.C
\*---------------------------------------------------------------------------*/ \*---------------------------------------------------------------------------*/
@ -62,8 +63,8 @@ class SIBS
static const scalar safe1, safe2, redMax, redMin, scaleMX; static const scalar safe1, safe2, redMax, redMin, scaleMX;
mutable scalarField a_; mutable scalarField a_;
mutable Matrix<scalar> alpha_; mutable scalarSquareMatrix alpha_;
mutable Matrix<scalar> d_p_; mutable scalarRectangularMatrix d_p_;
mutable scalarField x_p_; mutable scalarField x_p_;
mutable scalarField err_; mutable scalarField err_;
@ -71,7 +72,7 @@ class SIBS
mutable scalarField ySeq_; mutable scalarField ySeq_;
mutable scalarField yErr_; mutable scalarField yErr_;
mutable scalarField dfdx_; mutable scalarField dfdx_;
mutable Matrix<scalar> dfdy_; mutable scalarSquareMatrix dfdy_;
mutable label first_, kMax_, kOpt_; mutable label first_, kMax_, kOpt_;
mutable scalar epsOld_, xNew_; mutable scalar epsOld_, xNew_;
@ -85,13 +86,12 @@ class SIBS
const scalarField& y, const scalarField& y,
const scalarField& dydx, const scalarField& dydx,
const scalarField& dfdx, const scalarField& dfdx,
const Matrix<scalar>& dfdy, const scalarSquareMatrix& dfdy,
const scalar deltaX, const scalar deltaX,
const label nSteps, const label nSteps,
scalarField& yEnd scalarField& yEnd
) const; ) const;
void polyExtrapolate void polyExtrapolate
( (
const label iest, const label iest,
@ -100,7 +100,7 @@ class SIBS
scalarField& yz, scalarField& yz,
scalarField& dy, scalarField& dy,
scalarField& x_p, scalarField& x_p,
Matrix<scalar>& d_p scalarRectangularMatrix& d_p
) const; ) const;

3
src/ODE/ODESolvers/SIBS/SIMPR.C
View file

@ -25,7 +25,6 @@ License
\*---------------------------------------------------------------------------*/ \*---------------------------------------------------------------------------*/
#include "SIBS.H" #include "SIBS.H"
#include "simpleMatrix.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
@ -35,7 +34,7 @@ void Foam::SIBS::SIMPR
const scalarField& y, const scalarField& y,
const scalarField& dydx, const scalarField& dydx,
const scalarField& dfdx, const scalarField& dfdx,
const Matrix<scalar>& dfdy, const scalarSquareMatrix& dfdy,
const scalar deltaX, const scalar deltaX,
const label nSteps, const label nSteps,
scalarField& yEnd scalarField& yEnd

2
src/ODE/ODESolvers/SIBS/polyExtrapolate.C
View file

@ -36,7 +36,7 @@ void Foam::SIBS::polyExtrapolate
scalarField& yz, scalarField& yz,
scalarField& dy, scalarField& dy,
scalarField& x, scalarField& x,
Matrix<scalar>& d scalarRectangularMatrix& d
) const ) const
{ {
label n = yz.size(); label n = yz.size();

9
src/OSspecific/Unix/Make/files → src/OSspecific/POSIX/Make/files
View file

@ -2,17 +2,18 @@ signals/sigFpe.C
signals/sigSegv.C signals/sigSegv.C
signals/sigInt.C signals/sigInt.C
signals/sigQuit.C signals/sigQuit.C
regExp.C
timer.C timer.C
fileStat.C fileStat.C
Unix.C POSIX.C
cpuTime/cpuTime.C cpuTime/cpuTime.C
clockTime/clockTime.C clockTime/clockTime.C
multiThreader/multiThreader.C multiThreader/multiThreader.C
#ifndef SunOS64 #ifdef SunOS64
printStack.C
#else
dummyPrintStack.C dummyPrintStack.C
#else
printStack.C
#endif #endif
LIB = $(FOAM_LIBBIN)/libOSspecific LIB = $(FOAM_LIBBIN)/libOSspecific

0
src/OSspecific/POSIX/Make/options Normal file
View file

201
src/OSspecific/Unix/Unix.C → src/OSspecific/POSIX/POSIX.C
View file

@ -23,7 +23,7 @@ License
Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
Description Description
UNIX versions of the functions declated in OSspecific.H. POSIX versions of the functions declared in OSspecific.H
\*---------------------------------------------------------------------------*/ \*---------------------------------------------------------------------------*/
@ -32,7 +32,7 @@ Description
#endif #endif
#include "OSspecific.H" #include "OSspecific.H"
#include "Unix.H" #include "POSIX.H"
#include "foamVersion.H" #include "foamVersion.H"
#include "fileName.H" #include "fileName.H"
#include "fileStat.H" #include "fileStat.H"
@ -56,7 +56,7 @@ Description
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * // // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
defineTypeNameAndDebug(Foam::Unix, 0); defineTypeNameAndDebug(Foam::POSIX, 0);
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
@ -91,7 +91,9 @@ Foam::string Foam::getEnv(const word& envName)
} }
else else
{ {
return string::null; // Return null-constructed string rather than string::null
// to avoid cyclic dependencies in the construction of globals
return string();
} }
} }
@ -211,23 +213,23 @@ bool Foam::chDir(const fileName& dir)
} }
Foam::fileName Foam::dotFoam(const fileName& name) Foam::fileName Foam::findEtcFile(const fileName& name, bool mandatory)
{ {
// Search user files: // Search user files:
// ~~~~~~~~~~~~~~~~~~ // ~~~~~~~~~~~~~~~~~~
fileName searchDir = home()/".OpenFOAM"; fileName searchDir = home()/".OpenFOAM";
if (dir(searchDir)) if (isDir(searchDir))
{ {
// Check for user file in ~/.OpenFOAM/VERSION // Check for user file in ~/.OpenFOAM/VERSION
fileName fullName = searchDir/FOAMversion/name; fileName fullName = searchDir/FOAMversion/name;
if (exists(fullName)) if (isFile(fullName))
{ {
return fullName; return fullName;
} }
// Check for version-independent user file in ~/.OpenFOAM // Check for version-independent user file in ~/.OpenFOAM
fullName = searchDir/name; fullName = searchDir/name;
if (exists(fullName)) if (isFile(fullName))
{ {
return fullName; return fullName;
} }
@ -237,18 +239,18 @@ Foam::fileName Foam::dotFoam(const fileName& name)
// Search site files: // Search site files:
// ~~~~~~~~~~~~~~~~~~ // ~~~~~~~~~~~~~~~~~~
searchDir = getEnv("WM_PROJECT_INST_DIR"); searchDir = getEnv("WM_PROJECT_INST_DIR");
if (dir(searchDir)) if (isDir(searchDir))
{ {
// Check for site file in $WM_PROJECT_INST_DIR/site/VERSION // Check for site file in $WM_PROJECT_INST_DIR/site/VERSION
fileName fullName = searchDir/"site"/FOAMversion/name; fileName fullName = searchDir/"site"/FOAMversion/name;
if (exists(fullName)) if (isFile(fullName))
{ {
return fullName; return fullName;
} }
// Check for version-independent site file in $WM_PROJECT_INST_DIR/site // Check for version-independent site file in $WM_PROJECT_INST_DIR/site
fullName = searchDir/"site"/name; fullName = searchDir/"site"/name;
if (exists(fullName)) if (isFile(fullName))
{ {
return fullName; return fullName;
} }
@ -257,25 +259,36 @@ Foam::fileName Foam::dotFoam(const fileName& name)
// Search installation files: // Search installation files:
// ~~~~~~~~~~~~~~~~~~~~~~~~~~ // ~~~~~~~~~~~~~~~~~~~~~~~~~~
searchDir = getEnv("WM_PROJECT_DIR"); searchDir = getEnv("WM_PROJECT_DIR");
if (dir(searchDir)) if (isDir(searchDir))
{ {
// Check for shipped OpenFOAM file in $WM_PROJECT_DIR/etc // Check for shipped OpenFOAM file in $WM_PROJECT_DIR/etc
fileName fullName = searchDir/"etc"/name; fileName fullName = searchDir/"etc"/name;
if (exists(fullName)) if (isFile(fullName))
{ {
return fullName; return fullName;
} }
} }
// Not found // Not found
return fileName::null; // abort if the file is mandatory, otherwise return null
if (mandatory)
{
cerr<< "--> FOAM FATAL ERROR in Foam::findEtcFile() :"
" could not find mandatory file\n '"
<< name.c_str() << "'\n\n" << std::endl;
::exit(1);
}
// Return null-constructed fileName rather than fileName::null
// to avoid cyclic dependencies in the construction of globals
return fileName();
} }
bool Foam::mkDir(const fileName& pathName, mode_t mode) bool Foam::mkDir(const fileName& pathName, mode_t mode)
{ {
// empty names are meaningless // empty names are meaningless
if (!pathName.size()) if (pathName.empty())
{ {
return false; return false;
} }
@ -419,7 +432,7 @@ bool Foam::mkDir(const fileName& pathName, mode_t mode)
// Set the file mode // Set the file mode
bool Foam::chmod(const fileName& name, const mode_t m) bool Foam::chMod(const fileName& name, const mode_t m)
{ {
return ::chmod(name.c_str(), m) == 0; return ::chmod(name.c_str(), m) == 0;
} }
@ -429,7 +442,6 @@ bool Foam::chmod(const fileName& name, const mode_t m)
mode_t Foam::mode(const fileName& name) mode_t Foam::mode(const fileName& name)
{ {
fileStat fileStatus(name); fileStat fileStatus(name);
if (fileStatus.isValid()) if (fileStatus.isValid())
{ {
return fileStatus.status().st_mode; return fileStatus.status().st_mode;
@ -462,28 +474,28 @@ Foam::fileName::Type Foam::type(const fileName& name)
// Does the name exist in the filing system? // Does the name exist in the filing system?
bool Foam::exists(const fileName& name) bool Foam::exists(const fileName& name, const bool checkGzip)
{ {
return mode(name) || file(name); return mode(name) || isFile(name, checkGzip);
} }
// Does the file exist // Does the directory exist?
bool Foam::file(const fileName& name) bool Foam::isDir(const fileName& name)
{
return S_ISREG(mode(name)) || S_ISREG(mode(name + ".gz"));
}
// Does the directory exist
bool Foam::dir(const fileName& name)
{ {
return S_ISDIR(mode(name)); return S_ISDIR(mode(name));
} }
// Does the file exist?
bool Foam::isFile(const fileName& name, const bool checkGzip)
{
return S_ISREG(mode(name)) || (checkGzip && S_ISREG(mode(name + ".gz")));
}
// Return size of file // Return size of file
off_t Foam::size(const fileName& name) off_t Foam::fileSize(const fileName& name)
{ {
fileStat fileStatus(name); fileStat fileStatus(name);
if (fileStatus.isValid()) if (fileStatus.isValid())
@ -524,7 +536,7 @@ Foam::fileNameList Foam::readDir
// also used as increment if initial size found to be insufficient // also used as increment if initial size found to be insufficient
static const int maxNnames = 100; static const int maxNnames = 100;
if (Unix::debug) if (POSIX::debug)
{ {
Info<< "readDir(const fileName&, const fileType, const bool filtergz)" Info<< "readDir(const fileName&, const fileType, const bool filtergz)"
<< " : reading directory " << directory << endl; << " : reading directory " << directory << endl;
@ -533,7 +545,7 @@ Foam::fileNameList Foam::readDir
// Setup empty string list MAXTVALUES long // Setup empty string list MAXTVALUES long
fileNameList dirEntries(maxNnames); fileNameList dirEntries(maxNnames);
// Pointers to the Unix director system // Pointers to the directory entries
DIR *source; DIR *source;
struct dirent *list; struct dirent *list;
@ -545,7 +557,7 @@ Foam::fileNameList Foam::readDir
{ {
dirEntries.setSize(0); dirEntries.setSize(0);
if (Unix::debug) if (POSIX::debug)
{ {
Info<< "readDir(const fileName&, const fileType, " Info<< "readDir(const fileName&, const fileType, "
"const bool filtergz) : cannot open directory " "const bool filtergz) : cannot open directory "
@ -559,10 +571,10 @@ Foam::fileNameList Foam::readDir
{ {
fileName fName(list->d_name); fileName fName(list->d_name);
// ignore files begining with ., i.e. ., .. and .??* // ignore files begining with ., i.e. '.', '..' and '.*'
if (fName.size() > 0 && fName[size_t(0)] != '.') if (fName.size() && fName[0] != '.')
{ {
word fileNameExt = fName.ext(); word fExt = fName.ext();
if if
( (
@ -570,11 +582,11 @@ Foam::fileNameList Foam::readDir
|| ||
( (
type == fileName::FILE type == fileName::FILE
&& fName[fName.size()-1] != '~' && fName[fName.size()-1] != '~'
&& fileNameExt != "bak" && fExt != "bak"
&& fileNameExt != "BAK" && fExt != "BAK"
&& fileNameExt != "old" && fExt != "old"
&& fileNameExt != "save" && fExt != "save"
) )
) )
{ {
@ -585,7 +597,7 @@ Foam::fileNameList Foam::readDir
dirEntries.setSize(dirEntries.size() + maxNnames); dirEntries.setSize(dirEntries.size() + maxNnames);
} }
if (filtergz && fileNameExt == "gz") if (filtergz && fExt == "gz")
{ {
dirEntries[nEntries++] = fName.lessExt(); dirEntries[nEntries++] = fName.lessExt();
} }
@ -608,17 +620,17 @@ Foam::fileNameList Foam::readDir
} }
// Copy, recursively if necessary, the source top the destination // Copy, recursively if necessary, the source to the destination
bool Foam::cp(const fileName& src, const fileName& dest) bool Foam::cp(const fileName& src, const fileName& dest)
{ {
fileName destFile(dest);
// Make sure source exists. // Make sure source exists.
if (!exists(src)) if (!exists(src))
{ {
return false; return false;
} }
fileName destFile(dest);
// Check type of source file. // Check type of source file.
if (src.type() == fileName::FILE) if (src.type() == fileName::FILE)
{ {
@ -629,7 +641,7 @@ bool Foam::cp(const fileName& src, const fileName& dest)
} }
// Make sure the destination directory exists. // Make sure the destination directory exists.
if (!dir(destFile.path()) && !mkDir(destFile.path())) if (!isDir(destFile.path()) && !mkDir(destFile.path()))
{ {
return false; return false;
} }
@ -668,8 +680,8 @@ bool Foam::cp(const fileName& src, const fileName& dest)
destFile = destFile/src.component(src.components().size() -1); destFile = destFile/src.component(src.components().size() -1);
} }
// Make sure the destination directory extists. // Make sure the destination directory exists.
if (!dir(destFile) && !mkDir(destFile)) if (!isDir(destFile) && !mkDir(destFile))
{ {
return false; return false;
} }
@ -678,7 +690,7 @@ bool Foam::cp(const fileName& src, const fileName& dest)
fileNameList contents = readDir(src, fileName::FILE, false); fileNameList contents = readDir(src, fileName::FILE, false);
forAll(contents, i) forAll(contents, i)
{ {
if (Unix::debug) if (POSIX::debug)
{ {
Info<< "Copying : " << src/contents[i] Info<< "Copying : " << src/contents[i]
<< " to " << destFile/contents[i] << endl; << " to " << destFile/contents[i] << endl;
@ -692,7 +704,7 @@ bool Foam::cp(const fileName& src, const fileName& dest)
fileNameList subdirs = readDir(src, fileName::DIRECTORY); fileNameList subdirs = readDir(src, fileName::DIRECTORY);
forAll(subdirs, i) forAll(subdirs, i)
{ {
if (Unix::debug) if (POSIX::debug)
{ {
Info<< "Copying : " << src/subdirs[i] Info<< "Copying : " << src/subdirs[i]
<< " to " << destFile << endl; << " to " << destFile << endl;
@ -707,19 +719,19 @@ bool Foam::cp(const fileName& src, const fileName& dest)
} }
// Create a softlink. destFile should not exist. Returns true if successful. // Create a softlink. dst should not exist. Returns true if successful.
bool Foam::ln(const fileName& src, const fileName& dest) bool Foam::ln(const fileName& src, const fileName& dst)
{ {
if (Unix::debug) if (POSIX::debug)
{ {
Info<< "Create softlink from : " << src << " to " << dest Info<< "Create softlink from : " << src << " to " << dst
<< endl; << endl;
} }
if (exists(dest)) if (exists(dst))
{ {
WarningIn("ln(const fileName&, const fileName&)") WarningIn("ln(const fileName&, const fileName&)")
<< "destination " << dest << " already exists. Not linking." << "destination " << dst << " already exists. Not linking."
<< endl; << endl;
return false; return false;
} }
@ -731,48 +743,87 @@ bool Foam::ln(const fileName& src, const fileName& dest)
return false; return false;
} }
if (symlink(src.c_str(), dest.c_str()) == 0) if (symlink(src.c_str(), dst.c_str()) == 0)
{ {
return true; return true;
} }
else else
{ {
WarningIn("ln(const fileName&, const fileName&)") WarningIn("ln(const fileName&, const fileName&)")
<< "symlink from " << src << " to " << dest << " failed." << endl; << "symlink from " << src << " to " << dst << " failed." << endl;
return false; return false;
} }
} }
// Rename srcFile destFile // Rename srcFile dstFile
bool Foam::mv(const fileName& srcFile, const fileName& destFile) bool Foam::mv(const fileName& src, const fileName& dst)
{ {
if (Unix::debug) if (POSIX::debug)
{ {
Info<< "Move : " << srcFile << " to " << destFile << endl; Info<< "Move : " << src << " to " << dst << endl;
} }
if if
( (
(destFile.type() == fileName::DIRECTORY) dst.type() == fileName::DIRECTORY
&& (srcFile.type() != fileName::DIRECTORY) && src.type() != fileName::DIRECTORY
) )
{ {
const fileName destName(destFile/srcFile.name()); const fileName dstName(dst/src.name());
return rename(srcFile.c_str(), destName.c_str()) == 0; return rename(src.c_str(), dstName.c_str()) == 0;
} }
else else
{ {
return rename(srcFile.c_str(), destFile.c_str()) == 0; return rename(src.c_str(), dst.c_str()) == 0;
} }
} }
// Remove a file returning true if successful otherwise false //- Rename to a corresponding backup file
// If the backup file already exists, attempt with "01" .. "99" index
bool Foam::mvBak(const fileName& src, const std::string& ext)
{
if (POSIX::debug)
{
Info<< "mvBak : " << src << " to extension " << ext << endl;
}
if (exists(src, false))
{
const int maxIndex = 99;
char index[3];
for (int n = 0; n <= maxIndex; n++)
{
fileName dstName(src + "." + ext);
if (n)
{
sprintf(index, "%02d", n);
dstName += index;
}
// avoid overwriting existing files, except for the last
// possible index where we have no choice
if (!exists(dstName, false) || n == maxIndex)
{
return rename(src.c_str(), dstName.c_str()) == 0;
}
}
}
// fall-through: nothing to do
return false;
}
// Remove a file, returning true if successful otherwise false
bool Foam::rm(const fileName& file) bool Foam::rm(const fileName& file)
{ {
if (Unix::debug) if (POSIX::debug)
{ {
Info<< "Removing : " << file << endl; Info<< "Removing : " << file << endl;
} }
@ -792,20 +843,20 @@ bool Foam::rm(const fileName& file)
// Remove a dirctory and its contents // Remove a dirctory and its contents
bool Foam::rmDir(const fileName& directory) bool Foam::rmDir(const fileName& directory)
{ {
if (Unix::debug) if (POSIX::debug)
{ {
Info<< "rmdir(const fileName&) : " Info<< "rmDir(const fileName&) : "
<< "removing directory " << directory << endl; << "removing directory " << directory << endl;
} }
// Pointers to the Unix director system // Pointers to the directory entries
DIR *source; DIR *source;
struct dirent *list; struct dirent *list;
// Attempt to open directory and set the structure pointer // Attempt to open directory and set the structure pointer
if ((source = opendir(directory.c_str())) == NULL) if ((source = opendir(directory.c_str())) == NULL)
{ {
WarningIn("rmdir(const fileName&)") WarningIn("rmDir(const fileName&)")
<< "cannot open directory " << directory << endl; << "cannot open directory " << directory << endl;
return false; return false;
@ -825,7 +876,7 @@ bool Foam::rmDir(const fileName& directory)
{ {
if (!rmDir(path)) if (!rmDir(path))
{ {
WarningIn("rmdir(const fileName&)") WarningIn("rmDir(const fileName&)")
<< "failed to remove directory " << fName << "failed to remove directory " << fName
<< " while removing directory " << directory << " while removing directory " << directory
<< endl; << endl;
@ -839,7 +890,7 @@ bool Foam::rmDir(const fileName& directory)
{ {
if (!rm(path)) if (!rm(path))
{ {
WarningIn("rmdir(const fileName&)") WarningIn("rmDir(const fileName&)")
<< "failed to remove file " << fName << "failed to remove file " << fName
<< " while removing directory " << directory << " while removing directory " << directory
<< endl; << endl;
@ -855,7 +906,7 @@ bool Foam::rmDir(const fileName& directory)
if (!rm(directory)) if (!rm(directory))
{ {
WarningIn("rmdir(const fileName&)") WarningIn("rmDir(const fileName&)")
<< "failed to remove directory " << directory << endl; << "failed to remove directory " << directory << endl;
closedir(source); closedir(source);

14
src/OSspecific/Unix/Unix.H → src/OSspecific/POSIX/POSIX.H
View file

@ -23,18 +23,18 @@ License
Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
Namespace Namespace
Foam::Unix Foam::POSIX
Description Description
UNIX versions of OS-specific functions. OS-specific functions implemented in POSIX.
SourceFiles SourceFiles
Unix.C POSIX.C
\*---------------------------------------------------------------------------*/ \*---------------------------------------------------------------------------*/
#ifndef Unix_H #ifndef POSIX_H
#define Unix_H #define POSIX_H
#include "className.H" #include "className.H"
@ -45,10 +45,10 @@ namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Unix namespace POSIX
{ {
//- Declare name of the class and its debug switch //- Declare name of the class and its debug switch
NamespaceName("Unix"); NamespaceName("POSIX");
} }
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

0
src/OSspecific/Unix/clockTime/clockTime.C → src/OSspecific/POSIX/clockTime/clockTime.C
View file

0
src/OSspecific/Unix/clockTime/clockTime.H → src/OSspecific/POSIX/clockTime/clockTime.H
View file

0
src/OSspecific/Unix/cpuTime/cpuTime.C → src/OSspecific/POSIX/cpuTime/cpuTime.C
View file

0
src/OSspecific/Unix/cpuTime/cpuTime.H → src/OSspecific/POSIX/cpuTime/cpuTime.H
View file

0
src/OSspecific/Unix/dummyPrintStack.C → src/OSspecific/POSIX/dummyPrintStack.C
View file

0
src/OSspecific/Unix/fileStat.C → src/OSspecific/POSIX/fileStat.C
View file

0
src/OSspecific/Unix/fileStat.H → src/OSspecific/POSIX/fileStat.H
View file

0
src/OSspecific/Unix/multiThreader/multiThreader.C → src/OSspecific/POSIX/multiThreader/multiThreader.C
View file

0
src/OSspecific/Unix/multiThreader/multiThreader.H → src/OSspecific/POSIX/multiThreader/multiThreader.H
View file

0
src/OSspecific/Unix/multiThreader/threadHandler.H → src/OSspecific/POSIX/multiThreader/threadHandler.H
View file

0
src/OSspecific/Unix/multiThreader/threadHandlerI.H → src/OSspecific/POSIX/multiThreader/threadHandlerI.H
View file

12
src/OSspecific/Unix/printStack.C → src/OSspecific/POSIX/printStack.C
View file

@ -159,7 +159,7 @@ void getSymbolForRaw
const word& address const word& address
) )
{ {
if (filename.size() > 0 && filename[0] == '/') if (filename.size() && filename[0] == '/')
{ {
string fcnt = pOpen string fcnt = pOpen
( (
@ -305,7 +305,7 @@ void error::printStack(Ostream& os)
string::size_type space = line.rfind(' ') + 1; string::size_type space = line.rfind(' ') + 1;
fileName libPath = line.substr(space, line.size()-space); fileName libPath = line.substr(space, line.size()-space);
if (libPath.size() > 0 && libPath[0] == '/') if (libPath.size() && libPath[0] == '/')
{ {
string offsetString(line.substr(0, line.find('-'))); string offsetString(line.substr(0, line.find('-')));
IStringStream offsetStr(offsetString); IStringStream offsetStr(offsetString);
@ -350,7 +350,7 @@ void error::printStack(Ostream& os)
// not an absolute path // not an absolute path
if (programFile[0] != '/') if (programFile[0] != '/')
{ {
string tmp = pOpen("which "+programFile); string tmp = pOpen("which " + programFile);
if (tmp[0] == '/' || tmp[0] == '~') if (tmp[0] == '/' || tmp[0] == '~')
{ {
programFile = tmp; programFile = tmp;
@ -361,13 +361,13 @@ void error::printStack(Ostream& os)
string::size_type bracketPos = msg.find('('); string::size_type bracketPos = msg.find('(');
if (bracketPos != string::size_type(string::npos)) if (bracketPos != string::npos)
{ {
string::size_type start = bracketPos+1; string::size_type start = bracketPos+1;
string::size_type plusPos = msg.find('+', start); string::size_type plusPos = msg.find('+', start);
if (plusPos != string::size_type(string::npos)) if (plusPos != string::npos)
{ {
string cName(msg.substr(start, plusPos-start)); string cName(msg.substr(start, plusPos-start));
@ -394,7 +394,7 @@ void error::printStack(Ostream& os)
{ {
string::size_type endBracketPos = msg.find(')', start); string::size_type endBracketPos = msg.find(')', start);
if (endBracketPos != string::size_type(string::npos)) if (endBracketPos != string::npos)
{ {
string fullName(msg.substr(start, endBracketPos-start)); string fullName(msg.substr(start, endBracketPos-start));

216
src/OSspecific/POSIX/regExp.C Normal file
View file

@ -0,0 +1,216 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright held by original author
\\/ 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 <sys/types.h>
#include "regExp.H"
#include "label.H"
#include "string.H"
#include "List.H"
#include "IOstreams.H"
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
Foam::regExp::regExp()
:
preg_(0)
{}
Foam::regExp::regExp(const char* pattern, const bool ignoreCase)
:
preg_(0)
{
set(pattern, ignoreCase);
}
Foam::regExp::regExp(const std::string& pattern, const bool ignoreCase)
:
preg_(0)
{
set(pattern.c_str(), ignoreCase);
}
// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * //
Foam::regExp::~regExp()
{
clear();
}
// * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * * //
void Foam::regExp::set(const char* pattern, const bool ignoreCase) const
{
clear();
// avoid NULL pointer and zero-length patterns
if (pattern && *pattern)
{
preg_ = new regex_t;
int cflags = REG_EXTENDED;
if (ignoreCase)
{
cflags |= REG_ICASE;
}
if (regcomp(preg_, pattern, cflags) != 0)
{
FatalErrorIn
(
"regExp::set(const char*)"
) << "Failed to compile regular expression '" << pattern << "'"
<< exit(FatalError);
}
}
}
void Foam::regExp::set(const std::string& pattern, const bool ignoreCase) const
{
return set(pattern.c_str(), ignoreCase);
}
bool Foam::regExp::clear() const
{
if (preg_)
{
regfree(preg_);
delete preg_;
preg_ = 0;
return true;
}
return false;
}
std::string::size_type Foam::regExp::find(const std::string& str) const
{
if (preg_ && str.size())
{
size_t nmatch = 1;
regmatch_t pmatch[1];
if (regexec(preg_, str.c_str(), nmatch, pmatch, 0) == 0)
{
return pmatch[0].rm_so;
}
}
return string::npos;
}
bool Foam::regExp::match(const std::string& str) const
{
if (preg_ && str.size())
{
size_t nmatch = 1;
regmatch_t pmatch[1];
// also verify that the entire string was matched
// pmatch[0] is the entire match
if
(
regexec(preg_, str.c_str(), nmatch, pmatch, 0) == 0
&& (pmatch[0].rm_so == 0 && pmatch[0].rm_eo == label(str.size()))
)
{
return true;
}
}
return false;
}
bool Foam::regExp::match(const string& str, List<string>& groups) const
{
if (preg_ && str.size())
{
size_t nmatch = ngroups() + 1;
regmatch_t pmatch[nmatch];
// also verify that the entire string was matched
// pmatch[0] is the entire match
// pmatch[1..] are the (...) sub-groups
if
(
regexec(preg_, str.c_str(), nmatch, pmatch, 0) == 0
&& (pmatch[0].rm_so == 0 && pmatch[0].rm_eo == label(str.size()))
)
{
groups.setSize(ngroups());
label groupI = 0;
for (size_t matchI = 1; matchI < nmatch; matchI++)
{
if (pmatch[matchI].rm_so != -1 && pmatch[matchI].rm_eo != -1)
{
groups[groupI] = str.substr
(
pmatch[matchI].rm_so,
pmatch[matchI].rm_eo - pmatch[matchI].rm_so
);
}
else
{
groups[groupI].clear();
}
groupI++;
}
return true;
}
}
groups.clear();
return false;
}
// * * * * * * * * * * * * * * Member Operators * * * * * * * * * * * * * * //
void Foam::regExp::operator=(const char* pat)
{
set(pat);
}
void Foam::regExp::operator=(const std::string& pat)
{
set(pat);
}
// ************************************************************************* //

190
src/OSspecific/POSIX/regExp.H Normal file
View file

@ -0,0 +1,190 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright held by original author
\\/ M anipulation |
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
OpenFOAM is free software; you can redistribute it and/or modify it
under the terms of the GNU General Public License as published by the
Free Software Foundation; either version 2 of the License, or (at your
option) any later version.
OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
for more details.
You should have received a copy of the GNU General Public License
along with OpenFOAM; if not, write to the Free Software Foundation,
Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
Class
Foam::regExp
Description
Wrapper around POSIX extended regular expressions.
SeeAlso
The manpage regex(7) for more information about POSIX regular expressions.
These differ somewhat from @c Perl and @c sed regular expressions.
SourceFiles
regExp.C
\*---------------------------------------------------------------------------*/
#ifndef regExp_H
#define regExp_H
#include <regex.h>
#include <string>
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
// Forward declaration of classes
class string;
template<class T> class List;
/*---------------------------------------------------------------------------*\
Class regExp Declaration
\*---------------------------------------------------------------------------*/
class regExp
{
// Private data
//- Precompiled regular expression
mutable regex_t* preg_;
// Private member functions
//- Disallow default bitwise copy construct
regExp(const regExp&);
//- Disallow default bitwise assignment
void operator=(const regExp&);
public:
//- Is character a regular expression meta-character?
// any character: '.' \n
// quantifiers: '*', '+', '?' \n
// grouping: '(', '|', ')' \n
// range: '[', ']' \n
//
// Don't bother checking for '{digit}' bounds
inline static bool meta(char c)
{
return
(
(c == '.') // any character
|| (c == '*' || c == '+' || c == '?') // quantifiers
|| (c == '(' || c == ')' || c == '|') // grouping/branching
|| (c == '[' || c == ']') // range
);
}
// Constructors
//- Construct null
regExp();
//- Construct from character array, optionally ignoring case
regExp(const char*, const bool ignoreCase=false);
//- Construct from std::string (or string), optionally ignoring case
regExp(const std::string&, const bool ignoreCase=false);
// Destructor
~regExp();
// Member functions
//- Access
//- Return true if a precompiled expression does not exist
inline bool empty() const
{
return !preg_;
}
//- Does a precompiled expression exist?
inline bool exists() const
{
return preg_ ? true : false;
}
//- Return the number of (groups)
inline int ngroups() const
{
return preg_ ? preg_->re_nsub : 0;
}
//- Editing
//- Compile pattern into a regular expression, optionally ignoring case
void set(const char*, const bool ignoreCase=false) const;
//- Compile pattern into a regular expression, optionally ignoring case
void set(const std::string&, const bool ignoreCase=false) const;
//- Release precompiled expression.
// Returns true if precompiled expression existed before clear
bool clear() const;
//- Searching
//- Find position within string.
// Returns the index where it begins or string::npos if not found
std::string::size_type find(const std::string& str) const;
//- Return true if it matches the entire string
// The begin-of-line (^) and end-of-line ($) anchors are implicit
bool match(const std::string&) const;
//- Return true if it matches and sets the sub-groups matched
// The begin-of-line (^) and end-of-line ($) anchors are implicit
bool match(const string&, List<string>& groups) const;
//- Return true if the regex was found in within string
bool search(const std::string& str) const
{
return std::string::npos != find(str);
}
// Member Operators
//- Assign and compile pattern from a character array
// Always case sensitive
void operator=(const char*);
//- Assign and compile pattern from string
// Always case sensitive
void operator=(const std::string&);
};
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //

18
src/OSspecific/Unix/signals/sigFpe.C → src/OSspecific/POSIX/signals/sigFpe.C
View file

@ -24,8 +24,6 @@ License
\*---------------------------------------------------------------------------*/ \*---------------------------------------------------------------------------*/
#include <stdint.h>
#include "error.H" #include "error.H"
#include "sigFpe.H" #include "sigFpe.H"
@ -69,7 +67,7 @@ void* Foam::sigFpe::my_malloc_hook(size_t size, const void *caller)
result = malloc (size); result = malloc (size);
// initialize to signalling nan // initialize to signalling nan
# ifdef SP # ifdef WM_SP
const uint32_t sNAN = 0x7ff7fffflu; const uint32_t sNAN = 0x7ff7fffflu;
@ -178,7 +176,7 @@ Foam::sigFpe::~sigFpe()
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
void Foam::sigFpe::set() void Foam::sigFpe::set(const bool verbose)
{ {
if (oldAction_.sa_handler) if (oldAction_.sa_handler)
{ {
@ -191,6 +189,12 @@ void Foam::sigFpe::set()
if (env("FOAM_SIGFPE")) if (env("FOAM_SIGFPE"))
{ {
if (verbose)
{
Info<< "SigFpe : Enabling floating point exception trapping"
<< " (FOAM_SIGFPE)." << endl;
}
# ifdef LINUX_GNUC # ifdef LINUX_GNUC
feenableexcept feenableexcept
@ -241,6 +245,12 @@ void Foam::sigFpe::set()
if (env("FOAM_SETNAN")) if (env("FOAM_SETNAN"))
{ {
if (verbose)
{
Info<< "SetNaN : Initialising allocated memory to NaN"
<< " (FOAM_SETNAN)." << endl;
}
# ifdef LINUX_GNUC # ifdef LINUX_GNUC
// Set our malloc // Set our malloc

2
src/OSspecific/Unix/signals/sigFpe.H → src/OSspecific/POSIX/signals/sigFpe.H
View file

@ -107,7 +107,7 @@ public:
// Member functions // Member functions
void set(); void set(const bool verbose);
}; };

2
src/OSspecific/Unix/signals/sigInt.C → src/OSspecific/POSIX/signals/sigInt.C
View file

@ -81,7 +81,7 @@ Foam::sigInt::~sigInt()
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
void Foam::sigInt::set() void Foam::sigInt::set(const bool verbose)
{ {
if (oldAction_.sa_handler) if (oldAction_.sa_handler)
{ {

2
src/OSspecific/Unix/signals/sigInt.H → src/OSspecific/POSIX/signals/sigInt.H
View file

@ -78,7 +78,7 @@ public:
// Member functions // Member functions
void set(); void set(const bool verbose);
}; };

2
src/OSspecific/Unix/signals/sigQuit.C → src/OSspecific/POSIX/signals/sigQuit.C
View file

@ -83,7 +83,7 @@ Foam::sigQuit::~sigQuit()
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
void Foam::sigQuit::set() void Foam::sigQuit::set(const bool verbose)
{ {
if (oldAction_.sa_handler) if (oldAction_.sa_handler)
{ {

2
src/OSspecific/Unix/signals/sigQuit.H → src/OSspecific/POSIX/signals/sigQuit.H
View file

@ -78,7 +78,7 @@ public:
// Member functions // Member functions
void set(); void set(const bool verbose);
}; };

2
src/OSspecific/Unix/signals/sigSegv.C → src/OSspecific/POSIX/signals/sigSegv.C
View file

@ -83,7 +83,7 @@ Foam::sigSegv::~sigSegv()
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
void Foam::sigSegv::set() void Foam::sigSegv::set(const bool verbose)
{ {
if (oldAction_.sa_handler) if (oldAction_.sa_handler)
{ {

2
src/OSspecific/Unix/signals/sigSegv.H → src/OSspecific/POSIX/signals/sigSegv.H
View file

@ -78,7 +78,7 @@ public:
// Member functions // Member functions
void set(); void set(const bool verbose);
}; };

0
src/OSspecific/Unix/timer.C → src/OSspecific/POSIX/timer.C
View file

0
src/OSspecific/Unix/timer.H → src/OSspecific/POSIX/timer.H
View file

4
src/OSspecific/Unix/Make/options
View file

@ -1,4 +0,0 @@
EXE_INC = \
LIB_LIBS = \
-lpthread

106
src/OpenFOAM/Make/files
View file

@ -3,32 +3,42 @@ global/dimensionedConstants/dimensionedConstants.C
global/argList/argList.C global/argList/argList.C
global/clock/clock.C global/clock/clock.C
primitives/bool/bool.C bools = primitives/bools
primitives/bool/boolIO.C $(bools)/bool/bool.C
$(bools)/bool/boolIO.C
$(bools)/Switch/Switch.C
$(bools)/Switch/SwitchIO.C
primitives/char/charIO.C primitives/char/charIO.C
primitives/int/intIO.C
primitives/uint/uintIO.C ints = primitives/ints
primitives/long/longIO.C $(ints)/int/intIO.C
primitives/longLong/longLongIO.C $(ints)/uint/uintIO.C
primitives/ulong/ulongIO.C $(ints)/long/longIO.C
primitives/label/label.C $(ints)/longLong/longLongIO.C
$(ints)/ulong/ulongIO.C
$(ints)/label/label.C
$(ints)/uLabel/uLabel.C
primitives/Scalar/doubleScalar/doubleScalar.C primitives/Scalar/doubleScalar/doubleScalar.C
primitives/Scalar/floatScalar/floatScalar.C primitives/Scalar/floatScalar/floatScalar.C
primitives/Scalar/scalar/scalar.C primitives/Scalar/scalar/scalar.C
primitives/labelVector/labelVector.C primitives/DiagTensor/diagTensor/diagTensor.C
primitives/vector/vector.C primitives/SphericalTensor/sphericalTensor/sphericalTensor.C
primitives/vector2D/vector2D.C primitives/SphericalTensor/labelSphericalTensor/labelSphericalTensor.C
primitives/sphericalTensor/sphericalTensor.C primitives/SymmTensor/labelSymmTensor/labelSymmTensor.C
primitives/sphericalTensor2D/sphericalTensor2D.C primitives/SymmTensor/symmTensor/symmTensor.C
primitives/diagTensor/diagTensor.C primitives/Tensor/labelTensor/labelTensor.C
primitives/symmTensor/symmTensor.C primitives/Tensor/tensor/tensor.C
primitives/tensor/tensor.C primitives/Vector/complexVector/complexVector.C
primitives/tensor2D/tensor2D.C primitives/Vector/labelVector/labelVector.C
primitives/labelSphericalTensor/labelSphericalTensor.C primitives/Vector/vector/vector.C
primitives/labelSymmTensor/labelSymmTensor.C
primitives/labelTensor/labelTensor.C primitives/Tensor2D/tensor2D/tensor2D.C
primitives/SphericalTensor2D/sphericalTensor2D/sphericalTensor2D.C
primitives/Vector2D/vector2D/vector2D.C
primitives/complex/complex.C primitives/complex/complex.C
primitives/complexVector/complexVector.C
primitives/quaternion/quaternion.C primitives/quaternion/quaternion.C
primitives/septernion/septernion.C primitives/septernion/septernion.C
@ -39,6 +49,14 @@ $(strings)/word/word.C
$(strings)/word/wordIO.C $(strings)/word/wordIO.C
$(strings)/fileName/fileName.C $(strings)/fileName/fileName.C
$(strings)/fileName/fileNameIO.C $(strings)/fileName/fileNameIO.C
$(strings)/keyType/keyTypeIO.C
$(strings)/wordRe/wordReIO.C
primitives/hashes/Hasher/Hasher.C
sha1 = primitives/hashes/SHA1
$(sha1)/SHA1.C
$(sha1)/SHA1Digest.C
coordinateSystems/coordinateSystem.C coordinateSystems/coordinateSystem.C
coordinateSystems/coordinateSystems.C coordinateSystems/coordinateSystems.C
@ -68,6 +86,7 @@ primitiveLists = primitives/Lists
$(primitiveLists)/boolList.C $(primitiveLists)/boolList.C
$(primitiveLists)/labelIOList.C $(primitiveLists)/labelIOList.C
$(primitiveLists)/scalarList.C $(primitiveLists)/scalarList.C
$(primitiveLists)/scalarIOList.C
$(primitiveLists)/vectorList.C $(primitiveLists)/vectorList.C
$(primitiveLists)/sphericalTensorList.C $(primitiveLists)/sphericalTensorList.C
$(primitiveLists)/symmTensorList.C $(primitiveLists)/symmTensorList.C
@ -81,19 +100,14 @@ IOstreams = $(Streams)/IOstreams
$(IOstreams)/IOstream.C $(IOstreams)/IOstream.C
$(IOstreams)/versionNumber.C $(IOstreams)/versionNumber.C
$(IOstreams)/Istream.C $(IOstreams)/Istream.C
$(IOstreams)/IOprint.C
$(IOstreams)/IOcheck.C
$(IOstreams)/Ostream.C $(IOstreams)/Ostream.C
Sstreams = $(Streams)/Sstreams Sstreams = $(Streams)/Sstreams
$(Sstreams)/ISread.C $(Sstreams)/ISstream.C
$(Sstreams)/ISnextValid.C $(Sstreams)/OSstream.C
$(Sstreams)/ISreadToken.C $(Sstreams)/SstreamsPrint.C
$(Sstreams)/readHexLabel.C $(Sstreams)/readHexLabel.C
$(Sstreams)/OSwrite.C $(Sstreams)/prefixOSstream.C
$(Sstreams)/Sprint.C
$(Sstreams)/prefixOSstream/prefixOSwrite.C
$(Sstreams)/prefixOSstream/prefixOSprint.C
gzstream = $(Streams)/gzstream gzstream = $(Streams)/gzstream
$(gzstream)/gzstream.C $(gzstream)/gzstream.C
@ -103,19 +117,17 @@ $(Fstreams)/IFstream.C
$(Fstreams)/OFstream.C $(Fstreams)/OFstream.C
Tstreams = $(Streams)/Tstreams Tstreams = $(Streams)/Tstreams
$(Tstreams)/ITread.C $(Tstreams)/ITstream.C
$(Tstreams)/Tprint.C
StringStreams = $(Streams)/StringStreams StringStreams = $(Streams)/StringStreams
$(StringStreams)/StringStreamPrint.C $(StringStreams)/StringStreamsPrint.C
Pstreams = $(Streams)/Pstreams Pstreams = $(Streams)/Pstreams
$(Pstreams)/Pstream.C $(Pstreams)/Pstream.C
$(Pstreams)/PstreamCommsStruct.C $(Pstreams)/PstreamCommsStruct.C
$(Pstreams)/IPread.C $(Pstreams)/IPstream.C
$(Pstreams)/OPwrite.C $(Pstreams)/OPstream.C
$(Pstreams)/Pprint.C $(Pstreams)/PstreamsPrint.C
$(Pstreams)/IPreadToken.C
dictionary = db/dictionary dictionary = db/dictionary
$(dictionary)/dictionary.C $(dictionary)/dictionary.C
@ -136,6 +148,7 @@ $(dictionaryEntry)/dictionaryEntryIO.C
functionEntries = $(dictionary)/functionEntries functionEntries = $(dictionary)/functionEntries
$(functionEntries)/functionEntry/functionEntry.C $(functionEntries)/functionEntry/functionEntry.C
$(functionEntries)/includeEntry/includeEntry.C $(functionEntries)/includeEntry/includeEntry.C
$(functionEntries)/includeIfPresentEntry/includeIfPresentEntry.C
$(functionEntries)/inputModeEntry/inputModeEntry.C $(functionEntries)/inputModeEntry/inputModeEntry.C
$(functionEntries)/removeEntry/removeEntry.C $(functionEntries)/removeEntry/removeEntry.C
@ -158,14 +171,13 @@ $(regIOobject)/regIOobjectWrite.C
db/IOobjectList/IOobjectList.C db/IOobjectList/IOobjectList.C
db/objectRegistry/objectRegistry.C db/objectRegistry/objectRegistry.C
db/functionObject/functionObject.C
db/functionObjectList/functionObjectList.C
db/CallbackRegistry/CallbackRegistryName.C db/CallbackRegistry/CallbackRegistryName.C
db/dlLibraryTable/dlLibraryTable.C db/dlLibraryTable/dlLibraryTable.C
Switch = db/Switch db/functionObjects/functionObject/functionObject.C
$(Switch)/Switch.C db/functionObjects/functionObjectList/functionObjectList.C
$(Switch)/SwitchIO.C db/functionObjects/outputFilterOutputControl/outputFilterOutputControl.C
Time = db/Time Time = db/Time
$(Time)/TimePaths.C $(Time)/TimePaths.C
@ -319,7 +331,6 @@ $(tetCell)/tetCell.C
cellModeller = $(meshShapes)/cellModeller cellModeller = $(meshShapes)/cellModeller
$(cellModeller)/cellModeller.C $(cellModeller)/cellModeller.C
$(cellModeller)/cellModellerIO.C
cellModel = $(meshShapes)/cellModel cellModel = $(meshShapes)/cellModel
$(cellModel)/cellModel.C $(cellModel)/cellModel.C
@ -383,7 +394,7 @@ faceZone = $(zones)/faceZone
$(faceZone)/faceZone.C $(faceZone)/faceZone.C
$(faceZone)/newFaceZone.C $(faceZone)/newFaceZone.C
pointZone = $(zones)/pointZone pointZone = $(polyMesh)/zones/pointZone
$(pointZone)/pointZone.C $(pointZone)/pointZone.C
$(pointZone)/newPointZone.C $(pointZone)/newPointZone.C
@ -434,7 +445,6 @@ $(cellMatcher)/degenerateMatcher.C
mapPolyMesh = $(polyMesh)/mapPolyMesh mapPolyMesh = $(polyMesh)/mapPolyMesh
$(mapPolyMesh)/mapPolyMesh.C $(mapPolyMesh)/mapPolyMesh.C
$(mapPolyMesh)/pointMapper/pointMapper.C
$(mapPolyMesh)/faceMapper/faceMapper.C $(mapPolyMesh)/faceMapper/faceMapper.C
$(mapPolyMesh)/cellMapper/cellMapper.C $(mapPolyMesh)/cellMapper/cellMapper.C
$(mapPolyMesh)/mapDistribute/mapDistribute.C $(mapPolyMesh)/mapDistribute/mapDistribute.C
@ -486,6 +496,9 @@ meshTools = meshes/meshTools
$(meshTools)/matchPoints.C $(meshTools)/matchPoints.C
$(meshTools)/mergePoints.C $(meshTools)/mergePoints.C
fields/UniformDimensionedFields/uniformDimensionedFields.C
fields/cloud/cloud.C
Fields = fields/Fields Fields = fields/Fields
$(Fields)/labelField/labelField.C $(Fields)/labelField/labelField.C
$(Fields)/scalarField/scalarField.C $(Fields)/scalarField/scalarField.C
@ -495,8 +508,6 @@ $(Fields)/symmTensorField/symmTensorField.C
$(Fields)/tensorField/tensorField.C $(Fields)/tensorField/tensorField.C
$(Fields)/complexFields/complexFields.C $(Fields)/complexFields/complexFields.C
fields/cloud/cloud.C
$(Fields)/labelField/labelIOField.C $(Fields)/labelField/labelIOField.C
$(Fields)/scalarField/scalarIOField.C $(Fields)/scalarField/scalarIOField.C
$(Fields)/vectorField/vectorIOField.C $(Fields)/vectorField/vectorIOField.C
@ -506,6 +517,7 @@ $(Fields)/diagTensorField/diagTensorIOField.C
$(Fields)/symmTensorField/symmTensorIOField.C $(Fields)/symmTensorField/symmTensorIOField.C
$(Fields)/tensorField/tensorIOField.C $(Fields)/tensorField/tensorIOField.C
$(Fields)/transformField/transformField.C $(Fields)/transformField/transformField.C
pointPatchFields = fields/pointPatchFields pointPatchFields = fields/pointPatchFields
$(pointPatchFields)/pointPatchField/pointPatchFields.C $(pointPatchFields)/pointPatchField/pointPatchFields.C

17
src/OpenFOAM/containers/Dictionaries/Dictionary/Dictionary.C
View file

@ -28,22 +28,15 @@ Description
#include "Dictionary.H" #include "Dictionary.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
// Null constructor
template<class T> template<class T>
Dictionary<T>::Dictionary() Foam::Dictionary<T>::Dictionary()
{} {}
// Copy constructor
template<class T> template<class T>
Dictionary<T>::Dictionary(const Dictionary& dict) Foam::Dictionary<T>::Dictionary(const Dictionary& dict)
: :
DictionaryBase<IDLList<T>, T>(dict) DictionaryBase<IDLList<T>, T>(dict)
{} {}
@ -52,10 +45,10 @@ Dictionary<T>::Dictionary(const Dictionary& dict)
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
template<class T> template<class T>
bool Dictionary<T>::erase(const word& Keyword) bool Foam::Dictionary<T>::erase(const word& keyword)
{ {
T* tPtr; T* tPtr;
if ((tPtr = this->remove(Keyword))) if (tPtr = this->remove(keyword))
{ {
delete tPtr; delete tPtr;
return true; return true;
@ -69,6 +62,4 @@ bool Dictionary<T>::erase(const word& Keyword)
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// ************************************************************************* // // ************************************************************************* //

16
src/OpenFOAM/containers/Dictionaries/Dictionary/Dictionary.H
View file

@ -27,8 +27,10 @@ Class
Description Description
Gerneral purpose template dictionary class which manages the storage Gerneral purpose template dictionary class which manages the storage
associated with it. It is derived from DictionaryBase instantiated on associated with it.
a memory managed form of intrusive doubly-linked list of \<T\>.
It is derived from DictionaryBase instantiated on a memory managed form
of intrusive doubly-linked list of \<T\>.
SourceFiles SourceFiles
Dictionary.C Dictionary.C
@ -47,7 +49,7 @@ namespace Foam
{ {
/*---------------------------------------------------------------------------*\ /*---------------------------------------------------------------------------*\
Class Dictionary Declaration Class Dictionary Declaration
\*---------------------------------------------------------------------------*/ \*---------------------------------------------------------------------------*/
template<class T> template<class T>
@ -69,11 +71,9 @@ public:
// Member functions // Member functions
// Editing //- Remove an entry specified by keyword and delete the pointer.
// Returns true if the keyword was found
//- Remove an entry specified by keyword from the dictionary bool erase(const word& keyword);
// and delete it
bool erase(const word& keyword);
}; };

127
src/OpenFOAM/containers/Dictionaries/DictionaryBase/DictionaryBase.C
View file

@ -26,15 +26,10 @@ License
#include "DictionaryBase.H" #include "DictionaryBase.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
// * * * * * * * * * * * * * Private Member Functions * * * * * * * * * * * // // * * * * * * * * * * * * * Private Member Functions * * * * * * * * * * * //
template<class IDLListType, class T> template<class IDLListType, class T>
void DictionaryBase<IDLListType, T>::addEntries() void Foam::DictionaryBase<IDLListType, T>::addEntries()
{ {
for for
( (
@ -51,12 +46,15 @@ void DictionaryBase<IDLListType, T>::addEntries()
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
template<class IDLListType, class T> template<class IDLListType, class T>
DictionaryBase<IDLListType, T>::DictionaryBase() Foam::DictionaryBase<IDLListType, T>::DictionaryBase()
{} {}
template<class IDLListType, class T> template<class IDLListType, class T>
DictionaryBase<IDLListType, T>::DictionaryBase(const DictionaryBase& dict) Foam::DictionaryBase<IDLListType, T>::DictionaryBase
(
const DictionaryBase& dict
)
: :
IDLListType(dict) IDLListType(dict)
{ {
@ -66,17 +64,20 @@ DictionaryBase<IDLListType, T>::DictionaryBase(const DictionaryBase& dict)
template<class IDLListType, class T> template<class IDLListType, class T>
template<class INew> template<class INew>
DictionaryBase<IDLListType, T>::DictionaryBase(Istream& is, const INew& inewt) Foam::DictionaryBase<IDLListType, T>::DictionaryBase
(
Istream& is,
const INew& iNew
)
: :
IDLListType(is, inewt) IDLListType(is, iNew)
{ {
addEntries(); addEntries();
} }
// Istream constructor
template<class IDLListType, class T> template<class IDLListType, class T>
DictionaryBase<IDLListType, T>::DictionaryBase(Istream& is) Foam::DictionaryBase<IDLListType, T>::DictionaryBase(Istream& is)
: :
IDLListType(is) IDLListType(is)
{ {
@ -88,25 +89,60 @@ DictionaryBase<IDLListType, T>::DictionaryBase(Istream& is)
// Find and return T // Find and return T
template<class IDLListType, class T> template<class IDLListType, class T>
bool DictionaryBase<IDLListType, T>::found(const word& keyword) const bool Foam::DictionaryBase<IDLListType, T>::found(const word& keyword) const
{ {
return hashedTs_.found(keyword); return hashedTs_.found(keyword);
} }
// Find and return T* // Find and return T*, return NULL if not found
template<class IDLListType, class T> template<class IDLListType, class T>
const T* DictionaryBase<IDLListType, T>::lookup(const word& keyword) const const T* Foam::DictionaryBase<IDLListType, T>::lookupPtr
(
const word& keyword
) const
{
typename HashTable<T*>::const_iterator iter = hashedTs_.find(keyword);
if (iter != hashedTs_.end())
{
return *iter;
}
else
{
return NULL;
}
}
// Find and return T*, return NULL if not found
template<class IDLListType, class T>
T* Foam::DictionaryBase<IDLListType, T>::lookupPtr(const word& keyword)
{
typename HashTable<T*>::iterator iter = hashedTs_.find(keyword);
if (iter != hashedTs_.end())
{
return *iter;
}
else
{
return NULL;
}
}
// Find and return T*, FatalError if keyword not found
template<class IDLListType, class T>
const T* Foam::DictionaryBase<IDLListType, T>::lookup(const word& keyword) const
{ {
typename HashTable<T*>::const_iterator iter = hashedTs_.find(keyword); typename HashTable<T*>::const_iterator iter = hashedTs_.find(keyword);
if (iter == hashedTs_.end()) if (iter == hashedTs_.end())
{ {
// If keyword not found print error message ...
FatalErrorIn FatalErrorIn
( (
"DictionaryBase<IDLListType, T>::" "DictionaryBase<IDLListType, T>::lookup(const word&) const"
"lookup(const word& keyword) const"
) << keyword << " is undefined" ) << keyword << " is undefined"
<< exit(FatalError); << exit(FatalError);
} }
@ -115,18 +151,17 @@ const T* DictionaryBase<IDLListType, T>::lookup(const word& keyword) const
} }
// Find and return T* // Find and return T*, FatalError if keyword not found
template<class IDLListType, class T> template<class IDLListType, class T>
T* DictionaryBase<IDLListType, T>::lookup(const word& keyword) T* Foam::DictionaryBase<IDLListType, T>::lookup(const word& keyword)
{ {
typename HashTable<T*>::iterator iter = hashedTs_.find(keyword); typename HashTable<T*>::iterator iter = hashedTs_.find(keyword);
if (iter == hashedTs_.end()) if (iter == hashedTs_.end())
{ {
// If keyword not found print error message ...
FatalErrorIn FatalErrorIn
( (
"DictionaryBase<IDLListType, T>::lookup(const word& keyword)" "DictionaryBase<IDLListType, T>::lookup(const word&)"
) << keyword << " is undefined" ) << keyword << " is undefined"
<< exit(FatalError); << exit(FatalError);
} }
@ -137,7 +172,7 @@ T* DictionaryBase<IDLListType, T>::lookup(const word& keyword)
// Return the table of contents // Return the table of contents
template<class IDLListType, class T> template<class IDLListType, class T>
wordList DictionaryBase<IDLListType, T>::toc() const Foam::wordList Foam::DictionaryBase<IDLListType, T>::toc() const
{ {
wordList keywords(this->size()); wordList keywords(this->size());
@ -158,26 +193,28 @@ wordList DictionaryBase<IDLListType, T>::toc() const
// Add at head of dictionary // Add at head of dictionary
template<class IDLListType, class T> template<class IDLListType, class T>
void DictionaryBase<IDLListType, T>::insert(const word& keyword, T* tPtr) void Foam::DictionaryBase<IDLListType, T>::insert(const word& keyword, T* tPtr)
{ {
IDLListType::insert(tPtr); // NOTE: we should probably check that HashTable::insert actually worked
hashedTs_.insert(keyword, tPtr); hashedTs_.insert(keyword, tPtr);
IDLListType::insert(tPtr);
} }
// Add at tail of dictionary // Add at tail of dictionary
template<class IDLListType, class T> template<class IDLListType, class T>
void DictionaryBase<IDLListType, T>::append(const word& keyword, T* tPtr) void Foam::DictionaryBase<IDLListType, T>::append(const word& keyword, T* tPtr)
{ {
IDLListType::append(tPtr); // NOTE: we should probably check that HashTable::insert actually worked
hashedTs_.insert(keyword, tPtr); hashedTs_.insert(keyword, tPtr);
IDLListType::append(tPtr);
} }
template<class IDLListType, class T> template<class IDLListType, class T>
T* DictionaryBase<IDLListType, T>::remove(const word& Keyword) T* Foam::DictionaryBase<IDLListType, T>::remove(const word& keyword)
{ {
typename HashTable<T*>::iterator iter = hashedTs_.find(Keyword); typename HashTable<T*>::iterator iter = hashedTs_.find(keyword);
if (iter != hashedTs_.end()) if (iter != hashedTs_.end())
{ {
@ -192,19 +229,29 @@ T* DictionaryBase<IDLListType, T>::remove(const word& Keyword)
} }
//- Clear the dictionary
template<class IDLListType, class T> template<class IDLListType, class T>
void DictionaryBase<IDLListType, T>::clear() void Foam::DictionaryBase<IDLListType, T>::clear()
{ {
IDLListType::clear(); IDLListType::clear();
hashedTs_.clear(); hashedTs_.clear();
} }
template<class IDLListType, class T>
void Foam::DictionaryBase<IDLListType, T>::transfer
(
DictionaryBase<IDLListType, T>& dict
)
{
IDLListType::transfer(dict);
hashedTs_.transfer(dict.hashedTs_);
}
// * * * * * * * * * * * * * * * Member Operators * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * Member Operators * * * * * * * * * * * * * //
template<class IDLListType, class T> template<class IDLListType, class T>
void DictionaryBase<IDLListType, T>::operator= void Foam::DictionaryBase<IDLListType, T>::operator=
( (
const DictionaryBase<IDLListType, T>& dict const DictionaryBase<IDLListType, T>& dict
) )
@ -218,25 +265,11 @@ void DictionaryBase<IDLListType, T>::operator=
} }
IDLListType::operator=(dict); IDLListType::operator=(dict);
this->hashedTs_.clear(); this->hashedTs_.clear();
this->addEntries();
for
(
typename IDLListType::iterator iter = this->begin();
iter != this->end();
++iter
)
{
this->hashedTs_.insert((*iter).keyword(), &(*iter));
}
} }
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#include "DictionaryBaseIO.C" #include "DictionaryBaseIO.C"

34
src/OpenFOAM/containers/Dictionaries/DictionaryBase/DictionaryBase.H
View file

@ -29,12 +29,12 @@ Description
Base dictionary class templated on both the form of doubly-linked list Base dictionary class templated on both the form of doubly-linked list
it uses as well as the type it holds. it uses as well as the type it holds.
The double templating allows for the instantiation of forms with and The double templating allows for the instantiation of forms with or
without storage management. without storage management.
Note Note
The IDLListType parameter should itself be a template but this confused The IDLListType parameter should itself be a template but this confused
gcc 2.95.2 so it has to be instantiated for T when an intantiation of gcc 2.95.2 so it has to be instantiated for T when an instantiation of
DictionaryBase is requested DictionaryBase is requested
See Also See Also
@ -67,7 +67,7 @@ Ostream& operator<<(Ostream&, const DictionaryBase<IDLListType, T>&);
/*---------------------------------------------------------------------------*\ /*---------------------------------------------------------------------------*\
Class DictionaryBase Declaration Class DictionaryBase Declaration
\*---------------------------------------------------------------------------*/ \*---------------------------------------------------------------------------*/
template<class IDLListType, class T> template<class IDLListType, class T>
@ -77,7 +77,7 @@ class DictionaryBase
{ {
// Private data // Private data
//- HashTable of the enries held on the DL-list for quick lookup //- HashTable of the entries held on the IDLListType for quick lookup
HashTable<T*> hashedTs_; HashTable<T*> hashedTs_;
@ -99,10 +99,10 @@ public:
//- Construct from Istream using given Istream constructor class //- Construct from Istream using given Istream constructor class
template<class INew> template<class INew>
DictionaryBase(Istream& is, const INew& inewt); DictionaryBase(Istream&, const INew&);
//- Construct from Istream //- Construct from Istream using default Istream constructor class
DictionaryBase(Istream& is); DictionaryBase(Istream&);
// Member functions // Member functions
@ -110,7 +110,13 @@ public:
// Search and lookup // Search and lookup
//- Search DictionaryBase for given keyword //- Search DictionaryBase for given keyword
bool found(const word& keyword) const; bool found(const word&) const;
//- Find and return an entry if present, otherwise return NULL
const T* lookupPtr(const word&) const;
//- Find and return an entry if present, otherwise return NULL
T* lookupPtr(const word&);
//- Find and return entry //- Find and return entry
const T* lookup(const word&) const; const T* lookup(const word&) const;
@ -125,17 +131,21 @@ public:
// Editing // Editing
//- Add at head of dictionary //- Add at head of dictionary
void insert(const word& keyword, T*); void insert(const word&, T*);
//- Add at tail of dictionary //- Add at tail of dictionary
void append(const word& keyword, T*); void append(const word&, T*);
//- Remove and return entry specified by keyword //- Remove and return entry specified by keyword.
T* remove(const word& keyword); // Return NULL if the keyword was not found.
T* remove(const word&);
//- Clear the dictionary //- Clear the dictionary
void clear(); void clear();
//- Transfer the contents of the argument into this DictionaryBase
// and annull the argument.
void transfer(DictionaryBase<IDLListType, T>&);
// Member operators // Member operators

199
src/OpenFOAM/containers/HashTables/HashSet/HashSet.C Normal file
View file

@ -0,0 +1,199 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright held by original author
\\/ M anipulation |
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
OpenFOAM is free software; you can redistribute it and/or modify it
under the terms of the GNU General Public License as published by the
Free Software Foundation; either version 2 of the License, or (at your
option) any later version.
OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
for more details.
You should have received a copy of the GNU General Public License
along with OpenFOAM; if not, write to the Free Software Foundation,
Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
\*---------------------------------------------------------------------------*/
#ifndef HashSet_C
#define HashSet_C
#include "HashSet.H"
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
template<class Key, class Hash>
template<class AnyType, class AnyHash>
Foam::HashSet<Key, Hash>::HashSet
(
const HashTable<AnyType, Key, AnyHash>& h
)
:
HashTable<nil, Key, Hash>(h.size())
{
for
(
typename HashTable<AnyType, Key, AnyHash>::const_iterator
cit = h.cbegin();
cit != h.cend();
++cit
)
{
insert(cit.key());
}
}
// * * * * * * * * * * * * * * * Member Operators * * * * * * * * * * * * * //
template<class Key, class Hash>
inline bool Foam::HashSet<Key, Hash>::operator[](const Key& key) const
{
return found(key);
}
template<class Key, class Hash>
bool Foam::HashSet<Key, Hash>::operator==(const HashSet<Key, Hash>& rhs) const
{
// Are all lhs elements in rhs?
for (const_iterator iter = this->cbegin(); iter != this->cend(); ++iter)
{
if (!rhs.found(iter.key()))
{
return false;
}
}
// Are all rhs elements in lhs?
for (const_iterator iter = rhs.cbegin(); iter != rhs.cend(); ++iter)
{
if (!found(iter.key()))
{
return false;
}
}
return true;
}
template<class Key, class Hash>
bool Foam::HashSet<Key, Hash>::operator!=(const HashSet<Key, Hash>& rhs) const
{
return !(operator==(rhs));
}
template<class Key, class Hash>
void Foam::HashSet<Key, Hash>::operator|=(const HashSet<Key, Hash>& rhs)
{
// Add rhs elements into lhs
for (const_iterator iter = rhs.cbegin(); iter != rhs.cend(); ++iter)
{
insert(iter.key());
}
}
template<class Key, class Hash>
void Foam::HashSet<Key, Hash>::operator&=(const HashSet<Key, Hash>& rhs)
{
// Remove elements not also found in rhs
for (iterator iter = this->begin(); iter != this->end(); ++iter)
{
if (!rhs.found(iter.key()))
{
erase(iter);
}
}
}
template<class Key, class Hash>
void Foam::HashSet<Key, Hash>::operator^=(const HashSet<Key, Hash>& rhs)
{
// Add missed rhs elements, remove duplicate elements
for (const_iterator iter = rhs.cbegin(); iter != rhs.cend(); ++iter)
{
if (found(iter.key()))
{
erase(iter.key());
}
else
{
insert(iter.key());
}
}
}
// same as HashTable::erase()
template<class Key, class Hash>
void Foam::HashSet<Key, Hash>::operator-=(const HashSet<Key, Hash>& rhs)
{
// Remove rhs elements from lhs
for (const_iterator iter = rhs.cbegin(); iter != rhs.cend(); ++iter)
{
erase(iter.key());
}
}
/* * * * * * * * * * * * * * * * Global operators * * * * * * * * * * * * * */
template<class Key, class Hash>
Foam::HashSet<Key, Hash>
Foam::operator|
(
const HashSet<Key, Hash>& hash1,
const HashSet<Key, Hash>& hash2
)
{
HashSet<Key, Hash> out(hash1);
out |= hash2;
return out;
}
template<class Key, class Hash>
Foam::HashSet<Key, Hash>
Foam::operator&
(
const HashSet<Key, Hash>& hash1,
const HashSet<Key, Hash>& hash2
)
{
HashSet<Key, Hash> out(hash1);
out &= hash2;
return out;
}
template<class Key, class Hash>
Foam::HashSet<Key, Hash>
Foam::operator^
(
const HashSet<Key, Hash>& hash1,
const HashSet<Key, Hash>& hash2
)
{
HashSet<Key, Hash> out(hash1);
out ^= hash2;
return out;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //

140
src/OpenFOAM/containers/HashTables/HashSet/HashSet.H
View file

@ -26,7 +26,7 @@ Class
Foam::HashSet Foam::HashSet
Description Description
A HashTable with word keys but without contents. A HashTable with keys but without contents.
Typedef Typedef
Foam::wordHashSet Foam::wordHashSet
@ -34,13 +34,19 @@ Typedef
Description Description
A HashSet with (the default) word keys. A HashSet with (the default) word keys.
Typedef
Foam::labelHashSet
Description
A HashSet with label keys.
\*---------------------------------------------------------------------------*/ \*---------------------------------------------------------------------------*/
#ifndef HashSet_H #ifndef HashSet_H
#define HashSet_H #define HashSet_H
#include "HashTable.H" #include "HashTable.H"
#include "empty.H" #include "nil.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
@ -54,57 +60,149 @@ namespace Foam
template<class Key=word, class Hash=string::hash> template<class Key=word, class Hash=string::hash>
class HashSet class HashSet
: :
public HashTable<empty, Key, Hash> public HashTable<nil, Key, Hash>
{ {
public: public:
typedef typename HashTable<nil, Key, Hash>::iterator iterator;
typedef typename HashTable<nil, Key, Hash>::const_iterator const_iterator;
// Constructors // Constructors
//- Construct given initial map size //- Construct given initial size
explicit HashSet(label size = 100) HashSet(const label size = 128)
: :
HashTable<empty, Key, Hash>(size) HashTable<nil, Key, Hash>(size)
{} {}
//- Construct from Istream //- Construct from Istream
explicit HashSet(Istream& is) HashSet(Istream& is)
: :
HashTable<empty, Key, Hash>(is) HashTable<nil, Key, Hash>(is)
{} {}
//- Construct from UList of Key //- Construct from UList of Key
explicit HashSet(const UList<Key>& ul) HashSet(const UList<Key>& lst)
: :
HashTable<empty, Key, Hash>(2*ul.size()) HashTable<nil, Key, Hash>(2*lst.size())
{ {
forAll (ul, i) forAll(lst, i)
{ {
insert(ul[i]); insert(lst[i]);
} }
} }
//- Construct as copy //- Construct as copy
HashSet(const HashSet<Key, Hash>& hs) HashSet(const HashSet<Key, Hash>& hs)
: :
HashTable<empty, Key, Hash>(hs) HashTable<nil, Key, Hash>(hs)
{} {}
//- Construct by transferring the parameter contents
HashSet(const Xfer<HashSet<Key, Hash> >& hs)
:
HashTable<nil, Key, Hash>(hs)
{}
//- Construct by transferring the parameter contents
HashSet(const Xfer<HashTable<nil, Key, Hash> >& hs)
:
HashTable<nil, Key, Hash>(hs)
{}
//- Construct from the keys of another HashTable,
// the type of values held is arbitrary.
template<class AnyType, class AnyHash>
HashSet(const HashTable<AnyType, Key, AnyHash>&);
// Member Functions // Member Functions
// Edit // Edit
//- Insert a new hashedEntry //- Insert a new entry
bool insert(const Key& key) bool insert(const Key& key)
{ {
return HashTable<empty, Key, Hash>::insert(key, empty()); return HashTable<nil, Key, Hash>::insert(key, nil());
} }
//- Same as insert (cannot overwrite nil content)
bool set(const Key& key)
{
return HashTable<nil, Key, Hash>::insert(key, nil());
}
// Member Operators
//- Return true if the entry exists, same as found()
inline bool operator[](const Key&) const;
//- Equality. Two hashtables are equal when their contents are equal.
// Independent of table size or order.
bool operator==(const HashSet<Key, Hash>&) const;
//- The opposite of the equality operation.
bool operator!=(const HashSet<Key, Hash>&) const;
//- Combine entries from HashSets
void operator|=(const HashSet<Key, Hash>&);
//- Only retain entries found in both HashSets
void operator&=(const HashSet<Key, Hash>&);
//- Only retain unique entries (xor)
void operator^=(const HashSet<Key, Hash>&);
//- Add entries listed in the given HashSet to this HashSet
inline void operator+=(const HashSet<Key, Hash>& rhs)
{
this->operator|=(rhs);
}
//- Remove entries listed in the given HashSet from this HashSet
void operator-=(const HashSet<Key, Hash>&);
}; };
// Global Operators
//- Combine entries from HashSets
template<class Key, class Hash>
HashSet<Key,Hash> operator|
(
const HashSet<Key,Hash>& hash1,
const HashSet<Key,Hash>& hash2
);
//- Create a HashSet that only contains entries found in both HashSets
template<class Key, class Hash>
HashSet<Key,Hash> operator&
(
const HashSet<Key,Hash>& hash1,
const HashSet<Key,Hash>& hash2
);
//- Create a HashSet that only contains unique entries (xor)
template<class Key, class Hash>
HashSet<Key,Hash> operator^
(
const HashSet<Key,Hash>& hash1,
const HashSet<Key,Hash>& hash2
);
//- A HashSet with word keys.
typedef HashSet<> wordHashSet; typedef HashSet<> wordHashSet;
//- A HashSet with label keys.
typedef HashSet<label, Hash<label> > labelHashSet;
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
@ -112,6 +210,12 @@ typedef HashSet<> wordHashSet;
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#ifdef NoRepository
# include "HashSet.C"
#endif
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif #endif
// ************************************************************************* // // ************************************************************************* //

317
src/OpenFOAM/containers/HashTables/HashTable/HashTable.C
View file

@ -30,40 +30,64 @@ License
#include "HashTable.H" #include "HashTable.H"
#include "List.H" #include "List.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // // * * * * * * * * * * * * Private Member Functions * * * * * * * * * * * * //
namespace Foam 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 * * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
template<class T, class Key, class Hash> template<class T, class Key, class Hash>
HashTable<T, Key, Hash>::HashTable(const label size) Foam::HashTable<T, Key, Hash>::HashTable(const label size)
: :
tableSize_(size), HashTableName(),
table_(NULL),
nElmts_(0), nElmts_(0),
tableSize_(canonicalSize(size)),
table_(NULL),
endIter_(*this, NULL, 0), endIter_(*this, NULL, 0),
endConstIter_(*this, NULL, 0) endConstIter_(*this, NULL, 0)
{ {
if (tableSize_) if (tableSize_)
{ {
table_ = new hashedEntry*[tableSize_]; table_ = new hashedEntry*[tableSize_];
for (label i=0; i<tableSize_; i++)
for (label hashIdx = 0; hashIdx < tableSize_; hashIdx++)
{ {
table_[i] = 0; table_[hashIdx] = 0;
} }
} }
} }
template<class T, class Key, class Hash> template<class T, class Key, class Hash>
HashTable<T, Key, Hash>::HashTable(const HashTable<T, Key, Hash>& ht) Foam::HashTable<T, Key, Hash>::HashTable(const HashTable<T, Key, Hash>& ht)
: :
HashTableName(), HashTableName(),
nElmts_(0),
tableSize_(ht.tableSize_), tableSize_(ht.tableSize_),
table_(NULL), table_(NULL),
nElmts_(0),
endIter_(*this, NULL, 0), endIter_(*this, NULL, 0),
endConstIter_(*this, NULL, 0) endConstIter_(*this, NULL, 0)
{ {
@ -71,23 +95,39 @@ HashTable<T, Key, Hash>::HashTable(const HashTable<T, Key, Hash>& ht)
{ {
table_ = new hashedEntry*[tableSize_]; table_ = new hashedEntry*[tableSize_];
for (label i=0; i<tableSize_; i++) for (label hashIdx = 0; hashIdx < tableSize_; hashIdx++)
{ {
table_[i] = 0; table_[hashIdx] = 0;
} }
for (const_iterator iter = ht.begin(); iter != ht.end(); ++iter) for (const_iterator iter = ht.cbegin(); iter != ht.cend(); ++iter)
{ {
insert(iter.key(), *iter); insert(iter.key(), *iter);
} }
} }
} }
template<class T, class Key, class Hash>
Foam::HashTable<T, Key, Hash>::HashTable
(
const Xfer<HashTable<T, Key, Hash> >& ht
)
:
HashTableName(),
nElmts_(0),
tableSize_(0),
table_(NULL),
endIter_(*this, NULL, 0),
endConstIter_(*this, NULL, 0)
{
transfer(ht());
}
// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * //
template<class T, class Key, class Hash> template<class T, class Key, class Hash>
HashTable<T, Key, Hash>::~HashTable() Foam::HashTable<T, Key, Hash>::~HashTable()
{ {
if (table_) if (table_)
{ {
@ -100,15 +140,18 @@ HashTable<T, Key, Hash>::~HashTable()
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
template<class T, class Key, class Hash> template<class T, class Key, class Hash>
bool HashTable<T, Key, Hash>::found(const Key& key) const bool Foam::HashTable<T, Key, Hash>::found(const Key& key) const
{ {
if (tableSize_) if (nElmts_)
{ {
label ii = Hash()(key, tableSize_); const label hashIdx = hashKeyIndex(key);
for (hashedEntry* n=table_[ii]; n; n=n->next_) for (hashedEntry* ep = table_[hashIdx]; ep; ep = ep->next_)
{ {
if (key == n->key_) return true; if (key == ep->key_)
{
return true;
}
} }
} }
@ -125,20 +168,22 @@ bool HashTable<T, Key, Hash>::found(const Key& key) const
template<class T, class Key, class Hash> template<class T, class Key, class Hash>
typename HashTable<T, Key, Hash>::iterator HashTable<T, Key, Hash>::find typename Foam::HashTable<T, Key, Hash>::iterator
Foam::HashTable<T, Key, Hash>::find
( (
const Key& key const Key& key
) )
{ {
if (tableSize_) if (nElmts_)
{ {
label ii = Hash()(key, tableSize_); const label hashIdx = hashKeyIndex(key);
hashedEntry* prev = 0;
for (hashedEntry* n=table_[ii]; n; n=n->next_) for (hashedEntry* ep = table_[hashIdx]; ep; ep = ep->next_)
{ {
if (key == n->key_) return iterator(*this, n, ii); if (key == ep->key_)
prev = n; {
return iterator(*this, ep, hashIdx);
}
} }
} }
@ -155,20 +200,22 @@ typename HashTable<T, Key, Hash>::iterator HashTable<T, Key, Hash>::find
template<class T, class Key, class Hash> template<class T, class Key, class Hash>
typename HashTable<T, Key, Hash>::const_iterator HashTable<T, Key, Hash>::find typename Foam::HashTable<T, Key, Hash>::const_iterator
Foam::HashTable<T, Key, Hash>::find
( (
const Key& key const Key& key
) const ) const
{ {
if (tableSize_) if (nElmts_)
{ {
label ii = Hash()(key, tableSize_); const label hashIdx = hashKeyIndex(key);
hashedEntry* prev = 0;
for (hashedEntry* n=table_[ii]; n; n=n->next_) for (hashedEntry* ep = table_[hashIdx]; ep; ep = ep->next_)
{ {
if (key == n->key_) return const_iterator(*this, n, ii); if (key == ep->key_)
prev = n; {
return const_iterator(*this, ep, hashIdx);
}
} }
} }
@ -180,19 +227,18 @@ typename HashTable<T, Key, Hash>::const_iterator HashTable<T, Key, Hash>::find
} }
# endif # endif
return end(); return cend();
} }
// Return the table of contents // Return the table of contents
template<class T, class Key, class Hash> template<class T, class Key, class Hash>
List<Key> HashTable<T, Key, Hash>::toc() const Foam::List<Key> Foam::HashTable<T, Key, Hash>::toc() const
{ {
List<Key> tofc(nElmts_); List<Key> tofc(nElmts_);
label i = 0; label i = 0;
for (const_iterator iter = begin(); iter != end(); ++iter) for (const_iterator iter = cbegin(); iter != cend(); ++iter)
{ {
tofc[i++] = iter.key(); tofc[i++] = iter.key();
} }
@ -202,36 +248,37 @@ List<Key> HashTable<T, Key, Hash>::toc() const
template<class T, class Key, class Hash> template<class T, class Key, class Hash>
bool HashTable<T, Key, Hash>::set bool Foam::HashTable<T, Key, Hash>::set
( (
const Key& key, const Key& key,
const T& newEntry, const T& newEntry,
const bool protect const bool protect
) )
{ {
if (tableSize_ == 0) if (!tableSize_)
{ {
resize(2); resize(2);
} }
label ii = Hash()(key, tableSize_); const label hashIdx = hashKeyIndex(key);
hashedEntry* existing = 0; hashedEntry* existing = 0;
hashedEntry* prev = 0; hashedEntry* prev = 0;
for (hashedEntry* curr = table_[ii]; curr; curr = curr->next_) for (hashedEntry* ep = table_[hashIdx]; ep; ep = ep->next_)
{ {
if (key == curr->key_) if (key == ep->key_)
{ {
existing = curr; existing = ep;
break; break;
} }
prev = curr; prev = ep;
} }
// not found, insert it at the head // not found, insert it at the head
if (!existing) if (!existing)
{ {
table_[ii] = new hashedEntry(key, table_[ii], newEntry); table_[hashIdx] = new hashedEntry(key, table_[hashIdx], newEntry);
nElmts_++; nElmts_++;
if (double(nElmts_)/tableSize_ > 0.8) if (double(nElmts_)/tableSize_ > 0.8)
@ -256,7 +303,7 @@ bool HashTable<T, Key, Hash>::set
if (debug) if (debug)
{ {
Info<< "HashTable<T, Key, Hash>::set" Info<< "HashTable<T, Key, Hash>::set"
"(const Key& key, T newEntry, false) : " "(const Key& key, T newEntry, true) : "
"Cannot insert " << key << " already in hash table\n"; "Cannot insert " << key << " already in hash table\n";
} }
# endif # endif
@ -266,16 +313,16 @@ bool HashTable<T, Key, Hash>::set
{ {
// found - overwrite existing entry // found - overwrite existing entry
// this corresponds to the Perl convention // this corresponds to the Perl convention
hashedEntry* elemPtr = new hashedEntry(key, existing->next_, newEntry); hashedEntry* ep = new hashedEntry(key, existing->next_, newEntry);
// replace existing element - within list or insert at the head // replace existing element - within list or insert at the head
if (prev) if (prev)
{ {
prev->next_ = elemPtr; prev->next_ = ep;
} }
else else
{ {
table_[ii] = elemPtr; table_[hashIdx] = ep;
} }
delete existing; delete existing;
@ -286,34 +333,34 @@ bool HashTable<T, Key, Hash>::set
template<class T, class Key, class Hash> template<class T, class Key, class Hash>
bool HashTable<T, Key, Hash>::erase(const iterator& cit) bool Foam::HashTable<T, Key, Hash>::erase(const iterator& cit)
{ {
if (cit.elmtPtr_) // note: endIter_ also has 0 elmtPtr_ if (cit.elmtPtr_) // note: endIter_ also has 0 elmtPtr_
{ {
iterator& it = const_cast<iterator&>(cit); iterator& it = const_cast<iterator&>(cit);
// Search element before elmtPtr_ // Search element before elmtPtr_
hashedEntry* prevElmtPtr = 0; hashedEntry* prev = 0;
for (hashedEntry* n=table_[it.hashIndex_]; n; n=n->next_) for (hashedEntry* ep = table_[it.hashIndex_]; ep; ep = ep->next_)
{ {
if (n == it.elmtPtr_) if (ep == it.elmtPtr_)
{ {
break; break;
} }
prevElmtPtr = n; prev = ep;
} }
if (prevElmtPtr) if (prev)
{ {
// Have element before elmtPtr // Have element before elmtPtr
prevElmtPtr->next_ = it.elmtPtr_->next_; prev->next_ = it.elmtPtr_->next_;
delete it.elmtPtr_; delete it.elmtPtr_;
it.elmtPtr_ = prevElmtPtr; it.elmtPtr_ = prev;
} }
else else
{ {
// elmtPtr is first element on SLlist // elmtPtr is first element on SLList
table_[it.hashIndex_] = it.elmtPtr_->next_; table_[it.hashIndex_] = it.elmtPtr_->next_;
delete it.elmtPtr_; delete it.elmtPtr_;
@ -334,7 +381,7 @@ bool HashTable<T, Key, Hash>::erase(const iterator& cit)
else else
{ {
// No previous found. Mark with special value which is // No previous found. Mark with special value which is
// - not end() // - not end()/cend()
// - handled by operator++ // - handled by operator++
it.elmtPtr_ = reinterpret_cast<hashedEntry*>(this); it.elmtPtr_ = reinterpret_cast<hashedEntry*>(this);
it.hashIndex_ = -1; it.hashIndex_ = -1;
@ -369,13 +416,13 @@ bool HashTable<T, Key, Hash>::erase(const iterator& cit)
template<class T, class Key, class Hash> template<class T, class Key, class Hash>
bool HashTable<T, Key, Hash>::erase(const Key& key) bool Foam::HashTable<T, Key, Hash>::erase(const Key& key)
{ {
iterator it = find(key); iterator fnd = find(key);
if (it != end()) if (fnd != end())
{ {
return erase(it); return erase(fnd);
} }
else else
{ {
@ -385,14 +432,60 @@ bool HashTable<T, Key, Hash>::erase(const Key& key)
template<class T, class Key, class Hash> template<class T, class Key, class Hash>
void HashTable<T, Key, Hash>::resize(const label newSize) Foam::label Foam::HashTable<T, Key, Hash>::erase(const UList<Key>& keys)
{ {
label count = 0;
// Remove listed keys from this table
if (this->size())
{
forAll(keys, keyI)
{
if (erase(keys[keyI]))
{
count++;
}
}
}
return count;
}
template<class T, class Key, class Hash>
template<class AnyType, class AnyHash>
Foam::label Foam::HashTable<T, Key, Hash>::erase
(
const HashTable<AnyType, Key, AnyHash>& rhs
)
{
label count = 0;
// Remove rhs keys from this table - terminates early if possible
// Could optimize depending on which hash is smaller ...
for (iterator iter = begin(); iter != end(); ++iter)
{
if (rhs.found(iter.key()) && erase(iter))
{
count++;
}
}
return count;
}
template<class T, class Key, class Hash>
void Foam::HashTable<T, Key, Hash>::resize(const label sz)
{
label newSize = canonicalSize(sz);
if (newSize == tableSize_) if (newSize == tableSize_)
{ {
# ifdef FULLDEBUG # ifdef FULLDEBUG
if (debug) if (debug)
{ {
Info<< "HashTable<T, Key, Hash>::resize(const label newSize) : " Info<< "HashTable<T, Key, Hash>::resize(const label) : "
<< "new table size == old table size\n"; << "new table size == old table size\n";
} }
# endif # endif
@ -402,7 +495,7 @@ void HashTable<T, Key, Hash>::resize(const label newSize)
HashTable<T, Key, Hash>* newTable = new HashTable<T, Key, Hash>(newSize); HashTable<T, Key, Hash>* newTable = new HashTable<T, Key, Hash>(newSize);
for (const_iterator iter = begin(); iter != end(); ++iter) for (const_iterator iter = cbegin(); iter != cend(); ++iter)
{ {
newTable->insert(iter.key(), *iter); newTable->insert(iter.key(), *iter);
} }
@ -420,22 +513,22 @@ void HashTable<T, Key, Hash>::resize(const label newSize)
template<class T, class Key, class Hash> template<class T, class Key, class Hash>
void HashTable<T, Key, Hash>::clear() void Foam::HashTable<T, Key, Hash>::clear()
{ {
if (nElmts_) if (nElmts_)
{ {
for (label i=0; i<tableSize_; i++) for (label hashIdx = 0; hashIdx < tableSize_; hashIdx++)
{ {
if (table_[i]) if (table_[hashIdx])
{ {
hashedEntry* n = table_[i]; hashedEntry* ep = table_[hashIdx];
while(hashedEntry* next = n->next_) while (hashedEntry* next = ep->next_)
{ {
delete n; delete ep;
n = next; ep = next;
} }
delete n; delete ep;
table_[i] = 0; table_[hashIdx] = 0;
} }
} }
nElmts_ = 0; nElmts_ = 0;
@ -444,10 +537,22 @@ void HashTable<T, Key, Hash>::clear()
template<class T, class Key, class Hash> template<class T, class Key, class Hash>
void HashTable<T, Key, Hash>::transfer(HashTable<T, Key, Hash>& ht) void Foam::HashTable<T, Key, Hash>::clearStorage()
{ {
clear(); clear();
delete[] table_; resize(0);
}
template<class T, class Key, class Hash>
void Foam::HashTable<T, Key, Hash>::transfer(HashTable<T, Key, Hash>& ht)
{
// as per the Destructor
if (table_)
{
clear();
delete[] table_;
}
tableSize_ = ht.tableSize_; tableSize_ = ht.tableSize_;
ht.tableSize_ = 0; ht.tableSize_ = 0;
@ -463,10 +568,13 @@ void HashTable<T, Key, Hash>::transfer(HashTable<T, Key, Hash>& ht)
// * * * * * * * * * * * * * * * Member Operators * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * Member Operators * * * * * * * * * * * * * //
template<class T, class Key, class Hash> template<class T, class Key, class Hash>
void HashTable<T, Key, Hash>::operator=(const HashTable<T, Key, Hash>& ht) void Foam::HashTable<T, Key, Hash>::operator=
(
const HashTable<T, Key, Hash>& rhs
)
{ {
// Check for assignment to self // Check for assignment to self
if (this == &ht) if (this == &rhs)
{ {
FatalErrorIn FatalErrorIn
( (
@ -476,18 +584,63 @@ void HashTable<T, Key, Hash>::operator=(const HashTable<T, Key, Hash>& ht)
<< abort(FatalError); << abort(FatalError);
} }
clear(); // could be zero-sized from a previous transfer()
if (!tableSize_)
{
resize(rhs.tableSize_);
}
else
{
clear();
}
for (const_iterator iter = ht.begin(); iter != ht.end(); ++iter) for (const_iterator iter = rhs.cbegin(); iter != rhs.cend(); ++iter)
{ {
insert(iter.key(), *iter); insert(iter.key(), *iter);
} }
} }
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // template<class T, class Key, class Hash>
bool Foam::HashTable<T, Key, Hash>::operator==
(
const HashTable<T, Key, Hash>& rhs
) const
{
// Are all my elements in rhs?
for (const_iterator iter = cbegin(); iter != cend(); ++iter)
{
const_iterator fnd = rhs.find(iter.key());
if (fnd == rhs.cend() || fnd() != iter())
{
return false;
}
}
// Are all rhs elements in me?
for (const_iterator iter = rhs.cbegin(); iter != rhs.cend(); ++iter)
{
const_iterator fnd = find(iter.key());
if (fnd == cend() || fnd() != iter())
{
return false;
}
}
return true;
}
template<class T, class Key, class Hash>
bool Foam::HashTable<T, Key, Hash>::operator!=
(
const HashTable<T, Key, Hash>& rhs
) const
{
return !(operator==(rhs));
}
} // End namespace Foam
// * * * * * * * * * * * * * * * Friend Operators * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * Friend Operators * * * * * * * * * * * * * //

161
src/OpenFOAM/containers/HashTables/HashTable/HashTable.H
View file

@ -28,6 +28,13 @@ Class
Description Description
An STL-conforming hash table. An STL-conforming hash table.
Note
Hashing index collisions are handled via chaining using a singly-linked
list with the colliding entry being added to the head of the linked
list. Thus copying the hash table (or indeed even resizing it) will
often result in a different hash order. Use a sorted table-of-contents
when the hash order is important.
SourceFiles SourceFiles
HashTableI.H HashTableI.H
HashTable.C HashTable.C
@ -39,7 +46,9 @@ SourceFiles
#define HashTable_H #define HashTable_H
#include "label.H" #include "label.H"
#include "uLabel.H"
#include "word.H" #include "word.H"
#include "Xfer.H"
#include "className.H" #include "className.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
@ -49,22 +58,16 @@ namespace Foam
// Forward declaration of friend functions and operators // Forward declaration of friend functions and operators
template<class T> template<class T> class List;
class List; template<class T> class UList;
template<class T, class Key, class Hash> class HashTable; template<class T, class Key, class Hash> class HashTable;
template<class T, class Key, class Hash> class HashPtrTable;
template<class T, class Key, class Hash> Istream& operator>> template<class T, class Key, class Hash>
( Istream& operator>>(Istream&, HashTable<T, Key, Hash>&);
Istream&,
HashTable<T, Key, Hash>&
);
template<class T, class Key, class Hash> Ostream& operator<< template<class T, class Key, class Hash>
( Ostream& operator<<(Ostream&, const HashTable<T, Key, Hash>&);
Ostream&,
const HashTable<T, Key, Hash>&
);
/*---------------------------------------------------------------------------*\ /*---------------------------------------------------------------------------*\
@ -101,7 +104,7 @@ class HashTable
//- Construct given key, next pointer and object //- Construct given key, next pointer and object
inline hashedEntry inline hashedEntry
( (
const Key& key, const Key&,
hashedEntry* next, hashedEntry* next,
const T& newEntry const T& newEntry
); );
@ -113,20 +116,28 @@ class HashTable
// Private data: size of table, the table and current number of elements // Private data: size of table, the table and current number of elements
//- The current number of elements in table
label nElmts_;
//- Number of primary entries allocated in table (not necessarily used) //- Number of primary entries allocated in table (not necessarily used)
label tableSize_; label tableSize_;
//- The table of primary entries //- The table of primary entries
hashedEntry** table_; hashedEntry** table_;
//- The current number of elements in table
label nElmts_;
// Private Member Functions // Private Member Functions
//- Return a canonical (power-of-two) size
static label canonicalSize(const label);
//- Return the hash index of the Key within the current table size.
// No checks for zero-sized tables.
inline label hashKeyIndex(const Key&) const;
//- Assign a new hashedEntry to a possibly already existing key //- Assign a new hashedEntry to a possibly already existing key
bool set(const Key& key, const T& newElmt, bool protect); bool set(const Key&, const T& newElmt, bool protect);
public: public:
@ -147,14 +158,17 @@ public:
// Constructors // Constructors
//- Construct given initial table size //- Construct given initial table size
HashTable(const label size = 100); HashTable(const label size = 128);
//- Construct from Istream //- Construct from Istream
HashTable(Istream&, const label size = 100); HashTable(Istream&, const label size = 128);
//- Construct as copy //- Construct as copy
HashTable(const HashTable<T, Key, Hash>&); HashTable(const HashTable<T, Key, Hash>&);
//- Construct by transferring the parameter contents
HashTable(const Xfer<HashTable<T, Key, Hash> >&);
// Destructor // Destructor
@ -168,34 +182,50 @@ public:
//- Return number of elements in table. //- Return number of elements in table.
inline label size() const; inline label size() const;
//- Return true if the hash table is empty
inline bool empty() const;
//- Return true if hashedEntry is found in table //- Return true if hashedEntry is found in table
bool found(const Key& key) const; bool found(const Key&) const;
//- Find and return an iterator set at the hashedEntry //- Find and return an iterator set at the hashedEntry
// If not found iterator = end() // If not found iterator = end()
iterator find(const Key& key); iterator find(const Key&);
//- Find and return an const_iterator set at the hashedEntry //- Find and return an const_iterator set at the hashedEntry
// If not found iterator = end() // If not found iterator = end()
const_iterator find(const Key& key) const; const_iterator find(const Key&) const;
//- Return the table of contents //- Return the table of contents
List<Key> toc() const; List<Key> toc() const;
//- Print information
Ostream& printInfo(Ostream&) const;
// Edit // Edit
//- Insert a new hashedEntry //- Insert a new hashedEntry
inline bool insert(const Key& key, const T& newElmt); inline bool insert(const Key&, const T& newElmt);
//- Assign a new hashedEntry, overwriting existing entries //- Assign a new hashedEntry, overwriting existing entries
inline bool set(const Key& key, const T& newElmt); inline bool set(const Key&, const T& newElmt);
//- Erase an hashedEntry specified by given iterator //- Erase an hashedEntry specified by given iterator
bool erase(const iterator& it); bool erase(const iterator&);
//- Erase an hashedEntry specified by given key if in table //- Erase an hashedEntry specified by given key if in table
bool erase(const Key& key); bool erase(const Key&);
//- Remove entries given by the listed keys from this HashTable
// Return the number of elements removed
label erase(const UList<Key>&);
//- Remove entries given by the given keys from this HashTable
// Return the number of elements removed.
// The parameter HashTable needs the same type of key, but the
// type of values held and the hashing function are arbitrary.
template<class AnyType, class AnyHash>
label erase(const HashTable<AnyType, Key, AnyHash>&);
//- Resize the hash table for efficiency //- Resize the hash table for efficiency
void resize(const label newSize); void resize(const label newSize);
@ -203,26 +233,40 @@ public:
//- Clear all entries from table //- Clear all entries from table
void clear(); void clear();
//- Clear the table entries and the table itself.
// Equivalent to clear() followed by resize(0)
void clearStorage();
//- Transfer the contents of the argument table into this table //- Transfer the contents of the argument table into this table
// and annull the argument table. // and annull the argument table.
void transfer(HashTable<T, Key, Hash>&); void transfer(HashTable<T, Key, Hash>&);
//- Transfer contents to the Xfer container
inline Xfer<HashTable<T, Key, Hash> > xfer();
// Member Operators // Member Operators
//- Find and return an hashedEntry //- Find and return an hashedEntry
inline T& operator[](const Key& key); inline T& operator[](const Key&);
//- Find and return an hashedEntry //- Find and return an hashedEntry
inline const T& operator[](const Key& key) const; inline const T& operator[](const Key&) const;
//- Find and return an hashedEntry and //- Find and return an hashedEntry, create it null if not present.
// if it is not present create it null. inline T& operator()(const Key&);
inline T& operator()(const Key& key);
//- Assignment //- Assignment
void operator=(const HashTable<T, Key, Hash>&); void operator=(const HashTable<T, Key, Hash>&);
//- Equality. Two hash tables are equal if all contents of first are
// also in second and vice versa. So does not depend on table size or
// order!
bool operator==(const HashTable<T, Key, Hash>&) const;
//- The opposite of the equality operation. Takes linear time.
bool operator!=(const HashTable<T, Key, Hash>&) const;
// STL type definitions // STL type definitions
@ -253,7 +297,7 @@ public:
// Private data // Private data
//- Reference to the HashTable this is an iterator for //- Reference to the HashTable this is an iterator for
HashTable<T, Key, Hash>& curHashTable_; HashTable<T, Key, Hash>& hashTable_;
//- Current element //- Current element
hashedEntry* elmtPtr_; hashedEntry* elmtPtr_;
@ -261,7 +305,6 @@ public:
//- Current hash index //- Current hash index
label hashIndex_; label hashIndex_;
public: public:
// Constructors // Constructors
@ -274,24 +317,26 @@ public:
label hashIndex label hashIndex
); );
// Member operators // Member operators
inline void operator=(const iterator& iter); inline void operator=(const iterator&);
inline bool operator==(const iterator& iter) const; inline bool operator==(const iterator&) const;
inline bool operator!=(const iterator& iter) const; inline bool operator!=(const iterator&) const;
inline bool operator==(const const_iterator& iter) const; inline bool operator==(const const_iterator&) const;
inline bool operator!=(const const_iterator& iter) const; inline bool operator!=(const const_iterator&) const;
inline T& operator*(); inline T& operator*();
inline T& operator()(); inline T& operator()();
inline const T& operator*() const;
inline const T& operator()() const;
inline iterator& operator++(); inline iterator& operator++();
inline iterator operator++(int); inline iterator operator++(int);
inline const Key& key(); inline const Key& key() const;
}; };
@ -312,7 +357,7 @@ public:
// Private data // Private data
//- Reference to the HashTable this is an iterator for //- Reference to the HashTable this is an iterator for
const HashTable<T, Key, Hash>& curHashTable_; const HashTable<T, Key, Hash>& hashTable_;
//- Current element //- Current element
const hashedEntry* elmtPtr_; const hashedEntry* elmtPtr_;
@ -339,24 +384,30 @@ public:
// Member operators // Member operators
inline void operator=(const const_iterator& iter); inline void operator=(const const_iterator&);
inline bool operator==(const const_iterator& iter) const; inline bool operator==(const const_iterator&) const;
inline bool operator!=(const const_iterator& iter) const; inline bool operator!=(const const_iterator&) const;
inline bool operator==(const iterator& iter) const; inline bool operator==(const iterator&) const;
inline bool operator!=(const iterator& iter) const; inline bool operator!=(const iterator&) const;
inline const T& operator*(); inline const T& operator*() const;
inline const T& operator()(); inline const T& operator()() const;
inline const_iterator& operator++(); inline const_iterator& operator++();
inline const_iterator operator++(int); inline const_iterator operator++(int);
inline const Key& key(); 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 //- const_iterator set to the beginning of the HashTable
inline const_iterator begin() const; inline const_iterator begin() const;
@ -366,19 +417,13 @@ public:
// IOstream Operator // IOstream Operator
friend Istream& operator>> friend Istream& operator>> <T, Key, Hash>
#ifndef __CINT__
<T, Key, Hash>
#endif
( (
Istream&, Istream&,
HashTable<T, Key, Hash>& HashTable<T, Key, Hash>&
); );
friend Ostream& operator<< friend Ostream& operator<< <T, Key, Hash>
#ifndef __CINT__
<T, Key, Hash>
#endif
( (
Ostream&, Ostream&,
const HashTable<T, Key, Hash>& const HashTable<T, Key, Hash>&

227
src/OpenFOAM/containers/HashTables/HashTable/HashTableI.H
View file

@ -26,15 +26,10 @@ License
#include "error.H" #include "error.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
// * * * * * * * * * * * * * Private Member Classes * * * * * * * * * * * * // // * * * * * * * * * * * * * Private Member Classes * * * * * * * * * * * * //
template<class T, class Key, class Hash> template<class T, class Key, class Hash>
inline HashTable<T, Key, Hash>::hashedEntry::hashedEntry inline Foam::HashTable<T, Key, Hash>::hashedEntry::hashedEntry
( (
const Key& key, const Key& key,
hashedEntry* next, hashedEntry* next,
@ -47,39 +42,74 @@ inline HashTable<T, Key, Hash>::hashedEntry::hashedEntry
{} {}
// * * * * * * * * * * * * Private Member Functions * * * * * * * * * * * * //
template<class T, class Key, class Hash>
inline Foam::label
Foam::HashTable<T, Key, Hash>::hashKeyIndex(const Key& key) const
{
// size is power of two - this is the modulus
return Hash()(key) & (tableSize_ - 1);
}
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
template<class T, class Key, class Hash> template<class T, class Key, class Hash>
inline label HashTable<T, Key, Hash>::size() const inline Foam::label Foam::HashTable<T, Key, Hash>::size() const
{ {
return nElmts_; return nElmts_;
} }
template<class T, class Key, class Hash> template<class T, class Key, class Hash>
inline bool HashTable<T, Key, Hash>::insert(const Key& key, const T& newEntry) inline bool Foam::HashTable<T, Key, Hash>::empty() const
{
return !nElmts_;
}
template<class T, class Key, class Hash>
inline bool Foam::HashTable<T, Key, Hash>::insert
(
const Key& key,
const T& newEntry
)
{ {
return set(key, newEntry, true); return set(key, newEntry, true);
} }
template<class T, class Key, class Hash> template<class T, class Key, class Hash>
inline bool HashTable<T, Key, Hash>::set(const Key& key, const T& newEntry) inline bool Foam::HashTable<T, Key, Hash>::set
(
const Key& key,
const T& newEntry
)
{ {
return set(key, newEntry, false); return set(key, newEntry, false);
} }
template<class T, class Key, class Hash>
inline Foam::Xfer<Foam::HashTable<T, Key, Hash> >
Foam::HashTable<T, Key, Hash>::xfer()
{
return xferMove(*this);
}
// * * * * * * * * * * * * * * * Member Operators * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * Member Operators * * * * * * * * * * * * * //
template<class T, class Key, class Hash> template<class T, class Key, class Hash>
inline T& HashTable<T, Key, Hash>::operator[](const Key& key) inline T& Foam::HashTable<T, Key, Hash>::operator[](const Key& key)
{ {
iterator iter = find(key); iterator iter = find(key);
if (iter == end()) if (iter == end())
{ {
FatalErrorIn("HashTable<T, Key, Hash>::operator[](const Key&)") FatalErrorIn("HashTable<T, Key, Hash>::operator[](const Key&)")
<< key << " not found in table. Valid entries are " << key << " not found in table. Valid entries: "
<< toc() << toc()
<< exit(FatalError); << exit(FatalError);
} }
@ -87,15 +117,16 @@ inline T& HashTable<T, Key, Hash>::operator[](const Key& key)
return *iter; return *iter;
} }
template<class T, class Key, class Hash> template<class T, class Key, class Hash>
inline const T& HashTable<T, Key, Hash>::operator[](const Key& key) const inline const T& Foam::HashTable<T, Key, Hash>::operator[](const Key& key) const
{ {
const_iterator iter = find(key); const_iterator iter = find(key);
if (iter == end()) if (iter == cend())
{ {
FatalErrorIn("HashTable<T, Key, Hash>::operator[](const Key&) const") FatalErrorIn("HashTable<T, Key, Hash>::operator[](const Key&) const")
<< key << " not found in table. Valid entries are " << key << " not found in table. Valid entries: "
<< toc() << toc()
<< exit(FatalError); << exit(FatalError);
} }
@ -105,7 +136,7 @@ inline const T& HashTable<T, Key, Hash>::operator[](const Key& key) const
template<class T, class Key, class Hash> template<class T, class Key, class Hash>
inline T& HashTable<T, Key, Hash>::operator()(const Key& key) inline T& Foam::HashTable<T, Key, Hash>::operator()(const Key& key)
{ {
iterator iter = find(key); iterator iter = find(key);
@ -124,21 +155,24 @@ inline T& HashTable<T, Key, Hash>::operator()(const Key& key)
// * * * * * * * * * * * * * * * * STL iterator * * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * * STL iterator * * * * * * * * * * * * * * //
template<class T, class Key, class Hash> template<class T, class Key, class Hash>
inline HashTable<T, Key, Hash>::iterator::iterator inline Foam::HashTable<T, Key, Hash>::iterator::iterator
( (
HashTable<T, Key, Hash>& curHashTable, HashTable<T, Key, Hash>& hashTbl,
hashedEntry* elmt, hashedEntry* elmt,
label hashIndex label hashIndex
) )
: :
curHashTable_(curHashTable), hashTable_(hashTbl),
elmtPtr_(elmt), elmtPtr_(elmt),
hashIndex_(hashIndex) hashIndex_(hashIndex)
{} {}
template<class T, class Key, class Hash> template<class T, class Key, class Hash>
inline void HashTable<T, Key, Hash>::iterator::operator=(const iterator& iter) inline void Foam::HashTable<T, Key, Hash>::iterator::operator=
(
const iterator& iter
)
{ {
elmtPtr_ = iter.elmtPtr_; elmtPtr_ = iter.elmtPtr_;
hashIndex_ = iter.hashIndex_; hashIndex_ = iter.hashIndex_;
@ -146,7 +180,7 @@ inline void HashTable<T, Key, Hash>::iterator::operator=(const iterator& iter)
template<class T, class Key, class Hash> template<class T, class Key, class Hash>
inline bool HashTable<T, Key, Hash>::iterator::operator== inline bool Foam::HashTable<T, Key, Hash>::iterator::operator==
( (
const iterator& iter const iterator& iter
) const ) const
@ -156,7 +190,7 @@ inline bool HashTable<T, Key, Hash>::iterator::operator==
template<class T, class Key, class Hash> template<class T, class Key, class Hash>
inline bool HashTable<T, Key, Hash>::iterator::operator!= inline bool Foam::HashTable<T, Key, Hash>::iterator::operator!=
( (
const iterator& iter const iterator& iter
) const ) const
@ -166,7 +200,7 @@ inline bool HashTable<T, Key, Hash>::iterator::operator!=
template<class T, class Key, class Hash> template<class T, class Key, class Hash>
inline bool HashTable<T, Key, Hash>::iterator::operator== inline bool Foam::HashTable<T, Key, Hash>::iterator::operator==
( (
const const_iterator& iter const const_iterator& iter
) const ) const
@ -176,7 +210,7 @@ inline bool HashTable<T, Key, Hash>::iterator::operator==
template<class T, class Key, class Hash> template<class T, class Key, class Hash>
inline bool HashTable<T, Key, Hash>::iterator::operator!= inline bool Foam::HashTable<T, Key, Hash>::iterator::operator!=
( (
const const_iterator& iter const const_iterator& iter
) const ) const
@ -186,28 +220,46 @@ inline bool HashTable<T, Key, Hash>::iterator::operator!=
template<class T, class Key, class Hash> template<class T, class Key, class Hash>
inline T& HashTable<T, Key, Hash>::iterator::operator*() inline T&
Foam::HashTable<T, Key, Hash>::iterator::operator*()
{ {
return elmtPtr_->obj_; return elmtPtr_->obj_;
} }
template<class T, class Key, class Hash> template<class T, class Key, class Hash>
inline T& HashTable<T, Key, Hash>::iterator::operator()() inline T&
Foam::HashTable<T, Key, Hash>::iterator::operator()()
{ {
return operator*(); return elmtPtr_->obj_;
}
template<class T, class Key, class Hash>
inline const T&
Foam::HashTable<T, Key, Hash>::iterator::operator*() const
{
return elmtPtr_->obj_;
}
template<class T, class Key, class Hash>
inline const T&
Foam::HashTable<T, Key, Hash>::iterator::operator()() const
{
return elmtPtr_->obj_;
} }
template<class T, class Key, class Hash> template<class T, class Key, class Hash>
inline inline
typename HashTable<T, Key, Hash>::iterator& typename Foam::HashTable<T, Key, Hash>::iterator&
HashTable<T, Key, Hash>::iterator::operator++() Foam::HashTable<T, Key, Hash>::iterator::operator++()
{ {
// Check for special value from erase. (sets hashIndex to -1) // Check for special value from erase. (sets hashIndex to -1)
if (hashIndex_ >= 0) if (hashIndex_ >= 0)
{ {
// Do we have additional elements on the singly linked list? // Do we have additional elements on the SLList?
if (elmtPtr_ && elmtPtr_->next_) if (elmtPtr_ && elmtPtr_->next_)
{ {
elmtPtr_ = elmtPtr_->next_; elmtPtr_ = elmtPtr_->next_;
@ -218,24 +270,24 @@ HashTable<T, Key, Hash>::iterator::operator++()
// Step to the next table entry // Step to the next table entry
while while
( (
++hashIndex_ < curHashTable_.tableSize_ ++hashIndex_ < hashTable_.tableSize_
&& !(elmtPtr_ = curHashTable_.table_[hashIndex_]) && !(elmtPtr_ = hashTable_.table_[hashIndex_])
) )
{} {}
if (hashIndex_ == curHashTable_.tableSize_) if (hashIndex_ == hashTable_.tableSize_)
{ {
// make end iterator // make end iterator
hashIndex_ = 0;
elmtPtr_ = 0; elmtPtr_ = 0;
hashIndex_ = 0;
} }
return *this; return *this;
} }
template<class T, class Key, class Hash> template<class T, class Key, class Hash>
inline typename HashTable<T, Key, Hash>::iterator inline typename Foam::HashTable<T, Key, Hash>::iterator
HashTable<T, Key, Hash>::iterator::operator++ Foam::HashTable<T, Key, Hash>::iterator::operator++
( (
int int
) )
@ -248,20 +300,27 @@ HashTable<T, Key, Hash>::iterator::operator++
template<class T, class Key, class Hash> template<class T, class Key, class Hash>
inline inline
const Key& HashTable<T, Key, Hash>::iterator::key() const Key& Foam::HashTable<T, Key, Hash>::iterator::key() const
{ {
return elmtPtr_->key_; return elmtPtr_->key_;
} }
template<class T, class Key, class Hash> template<class T, class Key, class Hash>
inline typename HashTable<T, Key, Hash>::iterator inline typename Foam::HashTable<T, Key, Hash>::iterator
HashTable<T, Key, Hash>::begin() Foam::HashTable<T, Key, Hash>::begin()
{ {
label i = 0; label i = 0;
while (table_ && !table_[i] && ++i < tableSize_) if (nElmts_)
{} {
while (table_ && !table_[i] && ++i < tableSize_)
{}
}
else
{
i = tableSize_;
}
if (i == tableSize_) if (i == tableSize_)
{ {
@ -282,8 +341,8 @@ HashTable<T, Key, Hash>::begin()
template<class T, class Key, class Hash> template<class T, class Key, class Hash>
inline const typename HashTable<T, Key, Hash>::iterator& inline const typename Foam::HashTable<T, Key, Hash>::iterator&
HashTable<T, Key, Hash>::end() Foam::HashTable<T, Key, Hash>::end()
{ {
return HashTable<T, Key, Hash>::endIter_; return HashTable<T, Key, Hash>::endIter_;
} }
@ -292,33 +351,33 @@ HashTable<T, Key, Hash>::end()
// * * * * * * * * * * * * * * * STL const_iterator * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * STL const_iterator * * * * * * * * * * * * * //
template<class T, class Key, class Hash> template<class T, class Key, class Hash>
inline HashTable<T, Key, Hash>::const_iterator::const_iterator inline Foam::HashTable<T, Key, Hash>::const_iterator::const_iterator
( (
const HashTable<T, Key, Hash>& curHashTable, const HashTable<T, Key, Hash>& hashTbl,
const hashedEntry* elmt, const hashedEntry* elmt,
label hashIndex label hashIndex
) )
: :
curHashTable_(curHashTable), hashTable_(hashTbl),
elmtPtr_(elmt), elmtPtr_(elmt),
hashIndex_(hashIndex) hashIndex_(hashIndex)
{} {}
template<class T, class Key, class Hash> template<class T, class Key, class Hash>
inline HashTable<T, Key, Hash>::const_iterator::const_iterator inline Foam::HashTable<T, Key, Hash>::const_iterator::const_iterator
( (
const iterator& iter const iterator& iter
) )
: :
curHashTable_(iter.curHashTable_), hashTable_(iter.hashTable_),
elmtPtr_(iter.elmtPtr_), elmtPtr_(iter.elmtPtr_),
hashIndex_(iter.hashIndex_) hashIndex_(iter.hashIndex_)
{} {}
template<class T, class Key, class Hash> template<class T, class Key, class Hash>
inline void HashTable<T, Key, Hash>::const_iterator::operator= inline void Foam::HashTable<T, Key, Hash>::const_iterator::operator=
( (
const const_iterator& iter const const_iterator& iter
) )
@ -329,7 +388,7 @@ inline void HashTable<T, Key, Hash>::const_iterator::operator=
template<class T, class Key, class Hash> template<class T, class Key, class Hash>
inline bool HashTable<T, Key, Hash>::const_iterator::operator== inline bool Foam::HashTable<T, Key, Hash>::const_iterator::operator==
( (
const const_iterator& iter const const_iterator& iter
) const ) const
@ -339,7 +398,7 @@ inline bool HashTable<T, Key, Hash>::const_iterator::operator==
template<class T, class Key, class Hash> template<class T, class Key, class Hash>
inline bool HashTable<T, Key, Hash>::const_iterator::operator!= inline bool Foam::HashTable<T, Key, Hash>::const_iterator::operator!=
( (
const const_iterator& iter const const_iterator& iter
) const ) const
@ -349,7 +408,7 @@ inline bool HashTable<T, Key, Hash>::const_iterator::operator!=
template<class T, class Key, class Hash> template<class T, class Key, class Hash>
inline bool HashTable<T, Key, Hash>::const_iterator::operator== inline bool Foam::HashTable<T, Key, Hash>::const_iterator::operator==
( (
const iterator& iter const iterator& iter
) const ) const
@ -359,7 +418,7 @@ inline bool HashTable<T, Key, Hash>::const_iterator::operator==
template<class T, class Key, class Hash> template<class T, class Key, class Hash>
inline bool HashTable<T, Key, Hash>::const_iterator::operator!= inline bool Foam::HashTable<T, Key, Hash>::const_iterator::operator!=
( (
const iterator& iter const iterator& iter
) const ) const
@ -369,35 +428,36 @@ inline bool HashTable<T, Key, Hash>::const_iterator::operator!=
template<class T, class Key, class Hash> template<class T, class Key, class Hash>
inline const T& HashTable<T, Key, Hash>::const_iterator::operator*() inline const T&
Foam::HashTable<T, Key, Hash>::const_iterator::operator*() const
{ {
return elmtPtr_->obj_; return elmtPtr_->obj_;
} }
#ifndef __CINT__
template<class T, class Key, class Hash> template<class T, class Key, class Hash>
inline const T& HashTable<T, Key, Hash>::const_iterator::operator()() inline const T&
Foam::HashTable<T, Key, Hash>::const_iterator::operator()() const
{ {
return operator*(); return elmtPtr_->obj_;
} }
#endif
template<class T, class Key, class Hash> template<class T, class Key, class Hash>
inline inline
typename HashTable<T, Key, Hash>::const_iterator& typename Foam::HashTable<T, Key, Hash>::const_iterator&
HashTable<T, Key, Hash>::const_iterator::operator++() Foam::HashTable<T, Key, Hash>::const_iterator::operator++()
{ {
if if
( (
!(elmtPtr_ = elmtPtr_->next_) !(elmtPtr_ = elmtPtr_->next_)
&& ++hashIndex_ < curHashTable_.tableSize_ && ++hashIndex_ < hashTable_.tableSize_
&& !(elmtPtr_ = curHashTable_.table_[hashIndex_]) && !(elmtPtr_ = hashTable_.table_[hashIndex_])
) )
{ {
while while
( (
++hashIndex_ < curHashTable_.tableSize_ ++hashIndex_ < hashTable_.tableSize_
&& !(elmtPtr_ = curHashTable_.table_[hashIndex_]) && !(elmtPtr_ = hashTable_.table_[hashIndex_])
) )
{} {}
} }
@ -407,8 +467,8 @@ HashTable<T, Key, Hash>::const_iterator::operator++()
template<class T, class Key, class Hash> template<class T, class Key, class Hash>
inline typename HashTable<T, Key, Hash>::const_iterator inline typename Foam::HashTable<T, Key, Hash>::const_iterator
HashTable<T, Key, Hash>::const_iterator::operator++ Foam::HashTable<T, Key, Hash>::const_iterator::operator++
( (
int int
) )
@ -421,20 +481,27 @@ HashTable<T, Key, Hash>::const_iterator::operator++
template<class T, class Key, class Hash> template<class T, class Key, class Hash>
inline inline
const Key& HashTable<T, Key, Hash>::const_iterator::key() const Key& Foam::HashTable<T, Key, Hash>::const_iterator::key() const
{ {
return elmtPtr_->key_; return elmtPtr_->key_;
} }
template<class T, class Key, class Hash> template<class T, class Key, class Hash>
inline typename HashTable<T, Key, Hash>::const_iterator inline typename Foam::HashTable<T, Key, Hash>::const_iterator
HashTable<T, Key, Hash>::begin() const Foam::HashTable<T, Key, Hash>::cbegin() const
{ {
label i = 0; label i = 0;
while (table_ && !table_[i] && ++i < tableSize_) if (nElmts_)
{} {
while (table_ && !table_[i] && ++i < tableSize_)
{}
}
else
{
i = tableSize_;
}
if (i == tableSize_) if (i == tableSize_)
{ {
@ -455,15 +522,27 @@ HashTable<T, Key, Hash>::begin() const
template<class T, class Key, class Hash> template<class T, class Key, class Hash>
inline const typename HashTable<T, Key, Hash>::const_iterator& inline const typename Foam::HashTable<T, Key, Hash>::const_iterator&
HashTable<T, Key, Hash>::end() const Foam::HashTable<T, Key, Hash>::cend() const
{ {
return HashTable<T, Key, Hash>::endConstIter_; return HashTable<T, Key, Hash>::endConstIter_;
} }
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // template<class T, class Key, class Hash>
inline typename Foam::HashTable<T, Key, Hash>::const_iterator
Foam::HashTable<T, Key, Hash>::begin() const
{
return this->cbegin();
}
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_;
}
} // End namespace Foam
// ************************************************************************* // // ************************************************************************* //

92
src/OpenFOAM/containers/HashTables/HashTable/HashTableIO.C
View file

@ -33,38 +33,82 @@ License
template<class T, class Key, class Hash> template<class T, class Key, class Hash>
Foam::HashTable<T, Key, Hash>::HashTable(Istream& is, const label size) Foam::HashTable<T, Key, Hash>::HashTable(Istream& is, const label size)
: :
tableSize_(size), HashTableName(),
table_(new hashedEntry*[tableSize_]),
nElmts_(0), nElmts_(0),
tableSize_(canonicalSize(size)),
table_(new hashedEntry*[tableSize_]),
endIter_(*this, NULL, 0), endIter_(*this, NULL, 0),
endConstIter_(*this, NULL, 0) endConstIter_(*this, NULL, 0)
{ {
for (label i=0; i<tableSize_; i++) for (label hashIdx = 0; hashIdx < tableSize_; hashIdx++)
{ {
table_[i] = 0; table_[hashIdx] = 0;
} }
operator>>(is, *this); operator>>(is, *this);
} }
// * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * * //
template<class T, class Key, class Hash>
Foam::Ostream&
Foam::HashTable<T, Key, Hash>::printInfo(Ostream& os) const
{
label used = 0;
label maxChain = 0;
unsigned avgChain = 0;
for (label hashIdx = 0; hashIdx < tableSize_; ++hashIdx)
{
label count = 0;
for (hashedEntry* ep = table_[hashIdx]; ep; ep = ep->next_)
{
++count;
}
if (count)
{
++used;
avgChain += count;
if (maxChain < count)
{
maxChain = count;
}
}
}
os << "HashTable<T,Key,Hash>"
<< " elements:" << size() << " slots:" << used << "/" << tableSize_
<< " chaining(avg/max):" << (used ? (float(avgChain)/used) : 0)
<< "/" << maxChain << endl;
return os;
}
// * * * * * * * * * * * * * * * IOstream Operators * * * * * * * * * * * * // // * * * * * * * * * * * * * * * IOstream Operators * * * * * * * * * * * * //
template<class T, class Key, class Hash> template<class T, class Key, class Hash>
Foam::Istream& Foam::operator>>(Istream& is, HashTable<T, Key, Hash>& L) Foam::Istream& Foam::operator>>
(
Istream& is,
HashTable<T, Key, Hash>& L
)
{ {
is.fatalCheck("operator>>(Istream&, HashTable<T, Key, Hash>&)"); is.fatalCheck("operator>>(Istream&, HashTable<T, Key, Hash>&)");
// Anull list // Anull list
L.clear(); L.clear();
is.fatalCheck("operator>>(Istream& is, HashTable<T, Key, Hash>& L)"); is.fatalCheck("operator>>(Istream&, HashTable<T, Key, Hash>&)");
token firstToken(is); token firstToken(is);
is.fatalCheck is.fatalCheck
( (
"operator>>(Istream& is, HashTable<T, Key, Hash>& L) : " "operator>>(Istream&, HashTable<T, Key, Hash>&) : "
"reading first token" "reading first token"
); );
@ -73,7 +117,7 @@ Foam::Istream& Foam::operator>>(Istream& is, HashTable<T, Key, Hash>& L)
label s = firstToken.labelToken(); label s = firstToken.labelToken();
// Read beginning of contents // Read beginning of contents
char listDelimiter = is.readBeginList("HashTable<T, Key, Hash>"); char delimiter = is.readBeginList("HashTable<T, Key, Hash>");
if (s) if (s)
{ {
@ -82,7 +126,7 @@ Foam::Istream& Foam::operator>>(Istream& is, HashTable<T, Key, Hash>& L)
L.resize(2*s); L.resize(2*s);
} }
if (listDelimiter == token::BEGIN_LIST) if (delimiter == token::BEGIN_LIST)
{ {
for (label i=0; i<s; i++) for (label i=0; i<s; i++)
{ {
@ -101,7 +145,7 @@ Foam::Istream& Foam::operator>>(Istream& is, HashTable<T, Key, Hash>& L)
{ {
FatalIOErrorIn FatalIOErrorIn
( (
"operator>>(Istream& is, HashTable<T, Key, Hash>& L)", "operator>>(Istream&, HashTable<T, Key, Hash>&)",
is is
) << "incorrect first token, '(', found " << firstToken.info() ) << "incorrect first token, '(', found " << firstToken.info()
<< exit(FatalIOError); << exit(FatalIOError);
@ -117,7 +161,7 @@ Foam::Istream& Foam::operator>>(Istream& is, HashTable<T, Key, Hash>& L)
{ {
FatalIOErrorIn FatalIOErrorIn
( (
"operator>>(Istream& is, HashTable<T, Key, Hash>& L)", "operator>>(Istream&, HashTable<T, Key, Hash>&)",
is is
) << "incorrect first token, '(', found " << firstToken.info() ) << "incorrect first token, '(', found " << firstToken.info()
<< exit(FatalIOError); << exit(FatalIOError);
@ -133,10 +177,13 @@ Foam::Istream& Foam::operator>>(Istream& is, HashTable<T, Key, Hash>& L)
) )
{ {
is.putBack(lastToken); is.putBack(lastToken);
Key key; Key key;
is >> key; is >> key;
T element; T element;
is >> element; is >> element;
L.insert(key, element); L.insert(key, element);
is.fatalCheck is.fatalCheck
@ -152,7 +199,7 @@ Foam::Istream& Foam::operator>>(Istream& is, HashTable<T, Key, Hash>& L)
{ {
FatalIOErrorIn FatalIOErrorIn
( (
"operator>>(Istream& is, HashTable<T, Key, Hash>& L)", "operator>>(Istream&, HashTable<T, Key, Hash>&)",
is is
) << "incorrect first token, expected <int> or '(', found " ) << "incorrect first token, expected <int> or '(', found "
<< firstToken.info() << firstToken.info()
@ -166,26 +213,27 @@ Foam::Istream& Foam::operator>>(Istream& is, HashTable<T, Key, Hash>& L)
template<class T, class Key, class Hash> template<class T, class Key, class Hash>
Foam::Ostream& Foam::operator<<(Ostream& os, const HashTable<T, Key, Hash>& L) Foam::Ostream& Foam::operator<<
(
Ostream& os,
const HashTable<T, Key, Hash>& L
)
{ {
// Write size of HashTable // Write size and start delimiter
os << nl << L.size(); os << nl << L.size() << nl << token::BEGIN_LIST << nl;
// Write beginning of contents // Write contents
os << nl << token::BEGIN_LIST << nl;
// Write HashTable contents
for for
( (
typename HashTable<T, Key, Hash>::const_iterator iter = L.begin(); typename HashTable<T, Key, Hash>::const_iterator iter = L.cbegin();
iter != L.end(); iter != L.cend();
++iter ++iter
) )
{ {
os << iter.key() << token::SPACE << iter() << nl; os << iter.key() << token::SPACE << iter() << nl;
} }
// Write end of contents // Write end delimiter
os << token::END_LIST; os << token::END_LIST;
// Check state of IOstream // Check state of IOstream

22
src/OpenFOAM/containers/HashTables/Map/Map.H
View file

@ -55,10 +55,15 @@ class Map
public: public:
typedef typename HashTable<T, label, Hash<label> >::iterator iterator;
typedef typename HashTable<T, label, Hash<label> >::const_iterator
const_iterator;
// Constructors // Constructors
//- Construct given initial map size //- Construct given initial size
Map(label size = 100) Map(const label size = 128)
: :
HashTable<T, label, Hash<label> >(size) HashTable<T, label, Hash<label> >(size)
{} {}
@ -74,6 +79,19 @@ public:
: :
HashTable<T, label, Hash<label> >(map) HashTable<T, label, Hash<label> >(map)
{} {}
//- Construct by transferring the parameter contents
Map(const Xfer<Map<T> >& map)
:
HashTable<T, label, Hash<label> >(map)
{}
//- Construct by transferring the parameter contents
Map(const Xfer<HashTable<T, label, Hash<label> > >& map)
:
HashTable<T, label, Hash<label> >(map)
{}
}; };

2
src/OpenFOAM/containers/HashTables/PtrMap/PtrMap.H
View file

@ -58,7 +58,7 @@ public:
// Constructors // Constructors
//- Construct given initial map size //- Construct given initial map size
PtrMap(label size = 100) PtrMap(const label size = 128)
: :
HashPtrTable<T, label, Hash<label> >(size) HashPtrTable<T, label, Hash<label> >(size)
{} {}

367
src/OpenFOAM/containers/HashTables/StaticHashTable/StaticHashTable.C
View file

@ -31,20 +31,42 @@ License
#include "List.H" #include "List.H"
#include "IOstreams.H" #include "IOstreams.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // // * * * * * * * * * * * * Private Member Functions * * * * * * * * * * * * //
namespace Foam template<class T, class Key, class Hash>
Foam::label Foam::StaticHashTable<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 * * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
// Construct given initial table size // Construct given initial table size
template<class T, class Key, class Hash> template<class T, class Key, class Hash>
StaticHashTable<T, Key, Hash>::StaticHashTable(const label size) Foam::StaticHashTable<T, Key, Hash>::StaticHashTable(const label size)
: :
StaticHashTableName(), StaticHashTableName(),
keys_(size), keys_(canonicalSize(size)),
objects_(size), objects_(keys_.size()),
nElmts_(0), nElmts_(0),
endIter_(*this, keys_.size(), 0), endIter_(*this, keys_.size(), 0),
endConstIter_(*this, keys_.size(), 0) endConstIter_(*this, keys_.size(), 0)
@ -62,7 +84,7 @@ StaticHashTable<T, Key, Hash>::StaticHashTable(const label size)
// Construct as copy // Construct as copy
template<class T, class Key, class Hash> template<class T, class Key, class Hash>
StaticHashTable<T, Key, Hash>::StaticHashTable Foam::StaticHashTable<T, Key, Hash>::StaticHashTable
( (
const StaticHashTable<T, Key, Hash>& ht const StaticHashTable<T, Key, Hash>& ht
) )
@ -76,34 +98,54 @@ StaticHashTable<T, Key, Hash>::StaticHashTable
{} {}
template<class T, class Key, class Hash>
Foam::StaticHashTable<T, Key, Hash>::StaticHashTable
(
const Xfer< StaticHashTable<T, Key, Hash> >& ht
)
:
StaticHashTableName(),
keys_(0),
objects_(0),
nElmts_(0),
endIter_(*this, 0, 0),
endConstIter_(*this, 0, 0)
{
transfer(ht());
}
// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * //
template<class T, class Key, class Hash> template<class T, class Key, class Hash>
StaticHashTable<T, Key, Hash>::~StaticHashTable() Foam::StaticHashTable<T, Key, Hash>::~StaticHashTable()
{} {}
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
template<class T, class Key, class Hash> template<class T, class Key, class Hash>
bool StaticHashTable<T, Key, Hash>::found(const Key& key) const bool Foam::StaticHashTable<T, Key, Hash>::found(const Key& key) const
{ {
label ii = Hash()(key, keys_.size()); if (nElmts_)
const List<Key>& localKeys = keys_[ii];
forAll(localKeys, n)
{ {
if (localKeys[n] == key) const label hashIdx = hashKeyIndex(key);
const List<Key>& localKeys = keys_[hashIdx];
forAll(localKeys, elemIdx)
{ {
return true; if (key == localKeys[elemIdx])
{
return true;
}
} }
} }
# ifdef FULLDEBUG # ifdef FULLDEBUG
if (debug) if (debug)
{ {
Pout<< "StaticHashTable<T, Key, Hash>::found(const Key& key) : " Info<< "StaticHashTable<T, Key, Hash>::found(const Key&) : "
<< "Entry " << key << " not found in hash table\n"; << "Entry " << key << " not found in hash table\n";
} }
# endif # endif
@ -113,28 +155,30 @@ bool StaticHashTable<T, Key, Hash>::found(const Key& key) const
template<class T, class Key, class Hash> template<class T, class Key, class Hash>
typename StaticHashTable<T, Key, Hash>::iterator typename Foam::StaticHashTable<T, Key, Hash>::iterator
StaticHashTable<T, Key, Hash>::find Foam::StaticHashTable<T, Key, Hash>::find
( (
const Key& key const Key& key
) )
{ {
label ii = Hash()(key, keys_.size()); if (nElmts_)
const List<Key>& localKeys = keys_[ii];
forAll(localKeys, n)
{ {
if (localKeys[n] == key) const label hashIdx = hashKeyIndex(key);
const List<Key>& localKeys = keys_[hashIdx];
forAll(localKeys, elemIdx)
{ {
return iterator(*this, ii, n); if (key == localKeys[elemIdx])
{
return iterator(*this, hashIdx, elemIdx);
}
} }
} }
# ifdef FULLDEBUG # ifdef FULLDEBUG
if (debug) if (debug)
{ {
Pout<< "StaticHashTable<T, Key, Hash>::find(const Key& key) : " Info<< "StaticHashTable<T, Key, Hash>::find(const Key&) : "
<< "Entry " << key << " not found in hash table\n"; << "Entry " << key << " not found in hash table\n";
} }
# endif # endif
@ -144,45 +188,46 @@ StaticHashTable<T, Key, Hash>::find
template<class T, class Key, class Hash> template<class T, class Key, class Hash>
typename StaticHashTable<T, Key, Hash>::const_iterator typename Foam::StaticHashTable<T, Key, Hash>::const_iterator
StaticHashTable<T, Key, Hash>::find Foam::StaticHashTable<T, Key, Hash>::find
( (
const Key& key const Key& key
) const ) const
{ {
label ii = Hash()(key, keys_.size()); if (nElmts_)
const List<Key>& localKeys = keys_[ii];
forAll(localKeys, n)
{ {
if (localKeys[n] == key) const label hashIdx = hashKeyIndex(key);
const List<Key>& localKeys = keys_[hashIdx];
forAll(localKeys, elemIdx)
{ {
return const_iterator(*this, ii, n); if (key == localKeys[elemIdx])
{
return const_iterator(*this, hashIdx, elemIdx);
}
} }
} }
# ifdef FULLDEBUG # ifdef FULLDEBUG
if (debug) if (debug)
{ {
Pout<< "StaticHashTable<T, Key, Hash>::find(const Key& key) const : " Info<< "StaticHashTable<T, Key, Hash>::find(const Key&) const : "
<< "Entry " << key << " not found in hash table\n"; << "Entry " << key << " not found in hash table\n";
} }
# endif # endif
return end(); return cend();
} }
// Return the table of contents // Return the table of contents
template<class T, class Key, class Hash> template<class T, class Key, class Hash>
List<Key> StaticHashTable<T, Key, Hash>::toc() const Foam::List<Key> Foam::StaticHashTable<T, Key, Hash>::toc() const
{ {
List<Key> tofc(nElmts_); List<Key> tofc(nElmts_);
label i = 0; label i = 0;
for (const_iterator iter = begin(); iter != end(); ++iter) for (const_iterator iter = cbegin(); iter != cend(); ++iter)
{ {
tofc[i++] = iter.key(); tofc[i++] = iter.key();
} }
@ -192,57 +237,74 @@ List<Key> StaticHashTable<T, Key, Hash>::toc() const
template<class T, class Key, class Hash> template<class T, class Key, class Hash>
bool StaticHashTable<T, Key, Hash>::insert(const Key& key, const T& newEntry) bool Foam::StaticHashTable<T, Key, Hash>::set
(
const Key& key,
const T& newEntry,
const bool protect
)
{ {
label ii = Hash()(key, keys_.size()); const label hashIdx = hashKeyIndex(key);
List<Key>& localKeys = keys_[hashIdx];
List<Key>& localKeys = keys_[ii]; label existing = localKeys.size();
forAll(localKeys, elemIdx)
forAll(localKeys, n)
{ {
if (localKeys[n] == key) if (key == localKeys[elemIdx])
{ {
# ifdef FULLDEBUG existing = elemIdx;
if (debug) break;
{
Pout<< "StaticHashTable<T, Key, Hash>::insert"
"(const Key& key, T newEntry) : "
"Cannot insert " << key << " already in hash table\n";
}
# endif
return false;
} }
} }
if (existing == localKeys.size())
{
// not found, append
List<T>& localObjects = objects_[hashIdx];
// Append. localKeys.setSize(existing+1);
List<T>& localObjects = objects_[ii]; localObjects.setSize(existing+1);
label sz = localKeys.size(); localKeys[existing] = key;
localObjects[existing] = newEntry;
localKeys.setSize(sz+1); nElmts_++;
localObjects.setSize(sz+1); }
else if (protect)
localKeys[sz] = key; {
localObjects[sz] = newEntry; // found - but protected from overwriting
// this corresponds to the STL 'insert' convention
nElmts_++; # ifdef FULLDEBUG
if (debug)
{
Info<< "StaticHashTable<T, Key, Hash>::set"
"(const Key& key, T newEntry, true) : "
"Cannot insert " << key << " already in hash table\n";
}
# endif
return false;
}
else
{
// found - overwrite existing entry
// this corresponds to the Perl convention
objects_[hashIdx][existing] = newEntry;
}
return true; return true;
} }
template<class T, class Key, class Hash> template<class T, class Key, class Hash>
bool StaticHashTable<T, Key, Hash>::erase(const iterator& it) bool Foam::StaticHashTable<T, Key, Hash>::erase(const iterator& cit)
{ {
if (it != end()) if (cit != end())
{ {
List<Key>& localKeys = keys_[it.hashIndex_]; List<Key>& localKeys = keys_[cit.hashIndex_];
List<T>& localObjects = objects_[it.hashIndex_]; List<T>& localObjects = objects_[cit.hashIndex_];
// Copy down // Copy down
for (label i = it.elementIndex_+1; i < localKeys.size(); i++) for (label i = cit.elemIndex_+1; i < localKeys.size(); i++)
{ {
localKeys[i-1] = localKeys[i]; localKeys[i-1] = localKeys[i];
localObjects[i-1] = localObjects[i]; localObjects[i-1] = localObjects[i];
@ -250,12 +312,39 @@ bool StaticHashTable<T, Key, Hash>::erase(const iterator& it)
localKeys.setSize(localKeys.size()-1); localKeys.setSize(localKeys.size()-1);
localObjects.setSize(localObjects.size()-1); localObjects.setSize(localObjects.size()-1);
// adjust iterator after erase
iterator& it = const_cast<iterator&>(cit);
it.elemIndex_--;
if (it.elemIndex_ < 0)
{
// No previous element in the local list
// Search back for previous non-zero table entry
while (--it.hashIndex_ >= 0 && !objects_[it.hashIndex_].size())
{}
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_--; nElmts_--;
# ifdef FULLDEBUG # ifdef FULLDEBUG
if (debug) if (debug)
{ {
Pout<< "StaticHashTable<T, Key, Hash>::erase(iterator&) : " Info<< "StaticHashTable<T, Key, Hash>::erase(iterator&) : "
<< "hashedEntry removed.\n"; << "hashedEntry removed.\n";
} }
# endif # endif
@ -267,7 +356,7 @@ bool StaticHashTable<T, Key, Hash>::erase(const iterator& it)
# ifdef FULLDEBUG # ifdef FULLDEBUG
if (debug) if (debug)
{ {
Pout<< "StaticHashTable<T, Key, Hash>::erase(iterator&) : " Info<< "StaticHashTable<T, Key, Hash>::erase(iterator&) : "
<< "cannot remove hashedEntry from hash table\n"; << "cannot remove hashedEntry from hash table\n";
} }
# endif # endif
@ -278,7 +367,7 @@ bool StaticHashTable<T, Key, Hash>::erase(const iterator& it)
template<class T, class Key, class Hash> template<class T, class Key, class Hash>
bool StaticHashTable<T, Key, Hash>::erase(const Key& key) bool Foam::StaticHashTable<T, Key, Hash>::erase(const Key& key)
{ {
iterator it = find(key); iterator it = find(key);
@ -294,14 +383,38 @@ bool StaticHashTable<T, Key, Hash>::erase(const Key& key)
template<class T, class Key, class Hash> template<class T, class Key, class Hash>
void StaticHashTable<T, Key, Hash>::resize(const label newSize) Foam::label Foam::StaticHashTable<T, Key, Hash>::erase
(
const StaticHashTable<T, Key, Hash>& rhs
)
{ {
label count = 0;
// Remove rhs elements from this table
// NOTE: could optimize depending on which hash is smaller
for (iterator iter = this->begin(); iter != this->end(); ++iter)
{
if (rhs.found(iter.key()) && erase(iter))
{
count++;
}
}
return count;
}
template<class T, class Key, class Hash>
void Foam::StaticHashTable<T, Key, Hash>::resize(const label sz)
{
label newSize = canonicalSize(sz);
if (newSize == keys_.size()) if (newSize == keys_.size())
{ {
# ifdef FULLDEBUG # ifdef FULLDEBUG
if (debug) if (debug)
{ {
Pout<< "StaticHashTable<T, Key, Hash>::resize(const label) : " Info<< "StaticHashTable<T, Key, Hash>::resize(const label) : "
<< "new table size == old table size\n"; << "new table size == old table size\n";
} }
# endif # endif
@ -313,7 +426,7 @@ void StaticHashTable<T, Key, Hash>::resize(const label newSize)
{ {
FatalErrorIn FatalErrorIn
( (
"StaticHashTable<T, Key, Hash>::StaticHashTable(const label size)" "StaticHashTable<T, Key, Hash>::resize(const label)"
) << "Illegal size " << newSize << " for StaticHashTable." ) << "Illegal size " << newSize << " for StaticHashTable."
<< " Minimum size is 1" << abort(FatalError); << " Minimum size is 1" << abort(FatalError);
} }
@ -321,7 +434,7 @@ void StaticHashTable<T, Key, Hash>::resize(const label newSize)
StaticHashTable<T, Key, Hash> newTable(newSize); StaticHashTable<T, Key, Hash> newTable(newSize);
for (iterator iter = begin(); iter != end(); ++iter) for (const_iterator iter = cbegin(); iter != cend(); ++iter)
{ {
newTable.insert(iter.key(), *iter); newTable.insert(iter.key(), *iter);
} }
@ -335,46 +448,62 @@ void StaticHashTable<T, Key, Hash>::resize(const label newSize)
template<class T, class Key, class Hash> template<class T, class Key, class Hash>
void StaticHashTable<T, Key, Hash>::clear() void Foam::StaticHashTable<T, Key, Hash>::clear()
{ {
forAll(keys_, ii) forAll(keys_, hashIdx)
{ {
keys_[ii].clear(); keys_[hashIdx].clear();
objects_[ii].clear(); objects_[hashIdx].clear();
} }
nElmts_ = 0;
} }
template<class T, class Key, class Hash> template<class T, class Key, class Hash>
void StaticHashTable<T, Key, Hash>::transfer(StaticHashTable<T, Key, Hash>& ht) void Foam::StaticHashTable<T, Key, Hash>::clearStorage()
{ {
// Remove my existing elements clear();
resize(1);
}
template<class T, class Key, class Hash>
void Foam::StaticHashTable<T, Key, Hash>::transfer
(
StaticHashTable<T, Key, Hash>& ht
)
{
// Remove existing elements
clear(); clear();
// Copy data from ht // Copy data from ht
keys_.transfer(ht.keys_); keys_.transfer(ht.keys_);
objects_.transfer(ht.objects_); objects_.transfer(ht.objects_);
nElmts_ = ht.nElmts_; nElmts_ = ht.nElmts_;
ht.nElmts_ = 0;
// Adapt end() iterators // Adapt end() iterators
endIter_.hashIndex_ = keys_.size(); endIter_.hashIndex_ = keys_.size();
endConstIter_.hashIndex_ = keys_.size(); endConstIter_.hashIndex_ = keys_.size();
// Clear ht ht.endIter_.hashIndex_ = 0;
ht.nElmts_ = 0; ht.endConstIter_.hashIndex_ = 0;
} }
// * * * * * * * * * * * * * * * Member Operators * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * Member Operators * * * * * * * * * * * * * //
template<class T, class Key, class Hash> template<class T, class Key, class Hash>
void StaticHashTable<T, Key, Hash>::operator= void Foam::StaticHashTable<T, Key, Hash>::operator=
( (
const StaticHashTable<T, Key, Hash>& ht const StaticHashTable<T, Key, Hash>& rhs
) )
{ {
// Check for assignment to self // Check for assignment to self
if (this == &ht) if (this == &rhs)
{ {
FatalErrorIn FatalErrorIn
( (
@ -384,20 +513,70 @@ void StaticHashTable<T, Key, Hash>::operator=
<< abort(FatalError); << abort(FatalError);
} }
clear();
for (const_iterator iter = ht.begin(); iter != ht.end(); ++iter) // keys could be empty from a previous transfer()
if (keys_.empty())
{
keys_.setSize(rhs.keys_.size());
objects_.setSize(keys_.size());
// Adapt end() iterators
endIter_.hashIndex_ = keys_.size();
endConstIter_.hashIndex_ = keys_.size();
}
else
{
clear();
// keys_.size() does not change so neither does end() iterator.
}
for (const_iterator iter = rhs.cbegin(); iter != rhs.cend(); ++iter)
{ {
insert(iter.key(), *iter); insert(iter.key(), *iter);
} }
}
// keys_.size() does not change so neither does end() iterator. template<class T, class Key, class Hash>
bool Foam::StaticHashTable<T, Key, Hash>::operator==
(
const StaticHashTable<T, Key, Hash>& rhs
) const
{
// Are all my elements in rhs?
for (const_iterator iter = cbegin(); iter != cend(); ++iter)
{
const_iterator fnd = rhs.find(iter.key());
if (fnd == rhs.cend() || fnd() != iter())
{
return false;
}
}
// Are all rhs elements in me?
for (const_iterator iter = rhs.cbegin(); iter != rhs.cend(); ++iter)
{
const_iterator fnd = find(iter.key());
if (fnd == cend() || fnd() != iter())
{
return false;
}
}
return true;
} }
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // template<class T, class Key, class Hash>
bool Foam::StaticHashTable<T, Key, Hash>::operator!=
(
const StaticHashTable<T, Key, Hash>& rhs
) const
{
return !(operator==(rhs));
}
} // End namespace Foam
// * * * * * * * * * * * * * * * Friend Operators * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * Friend Operators * * * * * * * * * * * * * //

110
src/OpenFOAM/containers/HashTables/StaticHashTable/StaticHashTable.H
View file

@ -28,10 +28,10 @@ Class
Description Description
STL conforming hash table. STL conforming hash table.
Note
Uses straight lists as underlying type. Uses straight lists as underlying type.
Is slower to insert than the standard HashTable, but should be more Is slower to insert than the standard HashTable, but should be more
memory efficient and faster to access. memory efficient and faster to access.
Explicitly does not have default size.
SourceFiles SourceFiles
StaticHashTableI.H StaticHashTableI.H
@ -44,7 +44,9 @@ SourceFiles
#define StaticHashTable_H #define StaticHashTable_H
#include "label.H" #include "label.H"
#include "uLabel.H"
#include "word.H" #include "word.H"
#include "Xfer.H"
#include "className.H" #include "className.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
@ -54,9 +56,7 @@ namespace Foam
// Forward declaration of friend functions and operators // Forward declaration of friend functions and operators
template<class T> template<class T> class List;
class List;
template<class T, class Key, class Hash> class StaticHashTable; template<class T, class Key, class Hash> class StaticHashTable;
template<class T, class Key, class Hash> Istream& operator>> template<class T, class Key, class Hash> Istream& operator>>
@ -73,14 +73,14 @@ template<class T, class Key, class Hash> Ostream& operator<<
/*---------------------------------------------------------------------------*\ /*---------------------------------------------------------------------------*\
Class StaticHashTableName Declaration Class StaticHashTableName Declaration
\*---------------------------------------------------------------------------*/ \*---------------------------------------------------------------------------*/
TemplateName(StaticHashTable); TemplateName(StaticHashTable);
/*---------------------------------------------------------------------------*\ /*---------------------------------------------------------------------------*\
Class StaticHashTable Declaration Class StaticHashTable Declaration
\*---------------------------------------------------------------------------*/ \*---------------------------------------------------------------------------*/
template<class T, class Key=word, class Hash=string::hash> template<class T, class Key=word, class Hash=string::hash>
@ -99,6 +99,16 @@ class StaticHashTable
//- The current number of elements in table //- The current number of elements in table
label nElmts_; label nElmts_;
//- Return a canonical (power-of-two) size
static label canonicalSize(const label);
//- Return the hash index of the Key within the current table size.
// No checks for zero-sized tables.
inline label hashKeyIndex(const Key&) const;
//- Assign a new hashed entry to a possibly already existing key
bool set(const Key&, const T& newElmt, bool protect);
public: public:
@ -138,14 +148,16 @@ public:
// Constructors // Constructors
//- Construct given initial table size //- Construct given initial table size
StaticHashTable(const label size = 100); StaticHashTable(const label size = 128);
//- Construct from Istream //- Construct from Istream
StaticHashTable(Istream&, const label size = 100); StaticHashTable(Istream&, const label size = 128);
//- Construct as copy //- Construct as copy
StaticHashTable(const StaticHashTable<T, Key, Hash>&); StaticHashTable(const StaticHashTable<T, Key, Hash>&);
//- Construct by transferring the parameter contents
StaticHashTable(const Xfer< StaticHashTable<T, Key, Hash> >&);
// Destructor // Destructor
@ -159,54 +171,83 @@ public:
//- Return number of elements in table. //- Return number of elements in table.
inline label size() const; inline label size() const;
//- Return true if hashedEntry is found in table //- Return true if the hash table is empty
inline bool empty() const;
//- Return true if hashed entry is found in table
bool found(const Key& key) const; bool found(const Key& key) const;
//- Find and return an iterator set at the hashedEntry //- Find and return an iterator set at the hashed entry
// If not found iterator = end() // If not found iterator = end()
iterator find(const Key& key); iterator find(const Key& key);
//- Find and return an const_iterator set at the hashedEntry //- Find and return an const_iterator set at the hashed entry
// If not found iterator = end() // If not found iterator = end()
const_iterator find(const Key& key) const; const_iterator find(const Key& key) const;
//- Return the table of contents //- Return the table of contents
List<Key> toc() const; List<Key> toc() const;
//- Print information
Ostream& printInfo(Ostream&) const;
// Edit // Edit
//- Insert a new hashedEntry //- Insert a new hashed entry
bool insert(const Key& key, const T& newElmt); bool insert(const Key& key, const T& newElmt);
//- Erase an hashedEntry specified by given iterator //- Assign a new hashed entry, overwriting existing entries
inline bool set(const Key&, const T& newElmt);
//- Erase an hashed entry specified by given iterator
bool erase(const iterator& it); bool erase(const iterator& it);
//- Erase an hashedEntry specified by given key if in table //- Erase an hashed entry specified by given key if in table
bool erase(const Key& key); bool erase(const Key& key);
//- Resize the hash table for efficiency //- Resize the hash table for efficiency
void resize(const label newSize); void resize(const label newSize);
//- Remove entries in the given hash table from this hash table
// Return the number of elements removed
label erase(const StaticHashTable<T, Key, Hash>&);
//- Clear all entries from table //- Clear all entries from table
void clear(); void clear();
//- Clear the table entries and the table itself.
// Equivalent to clear() followed by resize(1)
void clearStorage();
//- Transfer the contents of the argument table into this table //- Transfer the contents of the argument table into this table
// and annull the argument table. // and annull the argument table.
void transfer(StaticHashTable<T, Key, Hash>&); void transfer(StaticHashTable<T, Key, Hash>&);
//- Transfer contents to the Xfer container
inline Xfer< StaticHashTable<T, Key, Hash> > xfer();
// Member Operators // Member Operators
//- Find and return an hashedEntry //- Find and return an hashed entry
inline T& operator[](const Key& key); inline T& operator[](const Key&);
//- Find and return an hashedEntry //- Find and return an hashed entry
inline const T& operator[](const Key& key) const; inline const T& operator[](const Key&) const;
//- Find and return an hashed entry, create it null if not present.
inline T& operator()(const Key&);
//- Assignment //- Assignment
void operator=(const StaticHashTable<T, Key, Hash>&); void operator=(const StaticHashTable<T, Key, Hash>&);
//- Equality. Two hash tables are equal if all contents of first are
// also in second and vice versa.
bool operator==(const StaticHashTable<T, Key, Hash>&) const;
//- The opposite of the equality operation.
bool operator!=(const StaticHashTable<T, Key, Hash>&) const;
// STL type definitions // STL type definitions
@ -242,24 +283,24 @@ public:
// Private data // Private data
//- Reference to the StaticHashTable this is an iterator for //- Reference to the StaticHashTable this is an iterator for
TableRef curStaticHashTable_; TableRef hashTable_;
//- Current hash index //- Current hash index
label hashIndex_; label hashIndex_;
//- Index of current element at hashIndex //- Index of current element at hashIndex
label elementIndex_; label elemIndex_;
public: public:
// Constructors // Constructors
//- Construct from hash table, element and hash index //- Construct from hash table, hash index and element index
inline Iterator inline Iterator
( (
TableRef curStaticHashTable, TableRef,
label hashIndex_, label hashIndex_,
label elementIndex_ label elemIndex_
); );
//- Construct from the non-const iterator //- Construct from the non-const iterator
@ -268,13 +309,13 @@ public:
// Member operators // Member operators
inline void operator=(const iterator& iter); inline void operator=(const iterator&);
inline bool operator==(const iterator& iter) const; inline bool operator==(const iterator&) const;
inline bool operator==(const const_iterator& iter) const; inline bool operator==(const const_iterator&) const;
inline bool operator!=(const iterator& iter) const; inline bool operator!=(const iterator&) const;
inline bool operator!=(const const_iterator& iter) const; inline bool operator!=(const const_iterator&) const;
inline TRef operator*(); inline TRef operator*();
inline TRef operator()(); inline TRef operator()();
@ -282,23 +323,28 @@ public:
inline Iterator& operator++(); inline Iterator& operator++();
inline Iterator operator++(int); inline Iterator operator++(int);
inline const Key& key(); inline const Key& key() const;
}; };
//- iterator set to the begining of the StaticHashTable //- iterator set to the beginning of the StaticHashTable
inline iterator begin(); inline iterator begin();
//- iterator set to beyond the end of the StaticHashTable //- iterator set to beyond the end of the StaticHashTable
inline const iterator& end(); inline const iterator& end();
//- const_iterator set to the begining of the StaticHashTable //- const_iterator set to the beginning of the StaticHashTable
inline const_iterator cbegin() const;
//- const_iterator set to beyond the end of the StaticHashTable
inline const const_iterator& cend() const;
//- const_iterator set to the beginning of the StaticHashTable
inline const_iterator begin() const; inline const_iterator begin() const;
//- const_iterator set to beyond the end of the StaticHashTable //- const_iterator set to beyond the end of the StaticHashTable
inline const const_iterator& end() const; inline const const_iterator& end() const;
// IOstream Operator // IOstream Operator
friend Istream& operator>> <T, Key, Hash> friend Istream& operator>> <T, Key, Hash>

270
src/OpenFOAM/containers/HashTables/StaticHashTable/StaticHashTableI.H
View file

@ -27,34 +27,76 @@ License
#include "error.H" #include "error.H"
#include "IOstreams.H" #include "IOstreams.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
// * * * * * * * * * * * * * Private Member Classes * * * * * * * * * * * * // // * * * * * * * * * * * * * Private Member Classes * * * * * * * * * * * * //
// * * * * * * * * * * * * Private Member Functions * * * * * * * * * * * * //
template<class T, class Key, class Hash>
inline Foam::label
Foam::StaticHashTable<T, Key, Hash>::hashKeyIndex(const Key& key) const
{
// size is power of two - this is the modulus
return Hash()(key) & (keys_.size() - 1);
}
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
template<class T, class Key, class Hash> template<class T, class Key, class Hash>
inline label StaticHashTable<T, Key, Hash>::size() const inline Foam::label Foam::StaticHashTable<T, Key, Hash>::size() const
{ {
return nElmts_; return nElmts_;
} }
template<class T, class Key, class Hash>
inline bool Foam::StaticHashTable<T, Key, Hash>::empty() const
{
return !nElmts_;
}
template<class T, class Key, class Hash>
inline bool Foam::StaticHashTable<T, Key, Hash>::insert
(
const Key& key,
const T& newEntry
)
{
return set(key, newEntry, true);
}
template<class T, class Key, class Hash>
inline bool Foam::StaticHashTable<T, Key, Hash>::set
(
const Key& key,
const T& newEntry
)
{
return set(key, newEntry, false);
}
template<class T, class Key, class Hash>
inline Foam::Xfer< Foam::StaticHashTable<T, Key, Hash> >
Foam::StaticHashTable<T, Key, Hash>::xfer()
{
return xferMove(*this);
}
// * * * * * * * * * * * * * * * Member Operators * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * Member Operators * * * * * * * * * * * * * //
template<class T, class Key, class Hash> template<class T, class Key, class Hash>
inline T& StaticHashTable<T, Key, Hash>::operator[](const Key& key) inline T& Foam::StaticHashTable<T, Key, Hash>::operator[](const Key& key)
{ {
iterator iter = find(key); iterator iter = find(key);
if (iter == end()) if (iter == end())
{ {
FatalErrorIn("StaticHashTable<T, Key, Hash>::operator[](const Key&)") FatalErrorIn("StaticHashTable<T, Key, Hash>::operator[](const Key&)")
<< key << " not found in table. Valid entries are " << key << " not found in table. Valid entries: "
<< toc() << toc()
<< exit(FatalError); << exit(FatalError);
} }
@ -62,17 +104,21 @@ inline T& StaticHashTable<T, Key, Hash>::operator[](const Key& key)
return *iter; return *iter;
} }
template<class T, class Key, class Hash> template<class T, class Key, class Hash>
inline const T& StaticHashTable<T, Key, Hash>::operator[](const Key& key) const inline const T& Foam::StaticHashTable<T, Key, Hash>::operator[]
(
const Key& key
) const
{ {
const_iterator iter = find(key); const_iterator iter = find(key);
if (iter == end()) if (iter == cend())
{ {
FatalErrorIn FatalErrorIn
( (
"StaticHashTable<T, Key, Hash>::operator[](const Key&) const" "StaticHashTable<T, Key, Hash>::operator[](const Key&) const"
) << key << " not found in table. Valid entries are " ) << key << " not found in table. Valid entries: "
<< toc() << toc()
<< exit(FatalError); << exit(FatalError);
} }
@ -81,74 +127,97 @@ inline const T& StaticHashTable<T, Key, Hash>::operator[](const Key& key) const
} }
template<class T, class Key, class Hash>
inline T& Foam::StaticHashTable<T, Key, Hash>::operator()(const Key& key)
{
iterator iter = find(key);
if (iter == end())
{
insert(key, T());
return *find(key);
}
else
{
return *iter;
}
}
// * * * * * * * * * * * * * * * * STL iterator * * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * * STL iterator * * * * * * * * * * * * * * //
template<class T, class Key, class Hash> template<class T, class Key, class Hash>
template<class TRef, class TableRef> template<class TRef, class TableRef>
inline StaticHashTable<T, Key, Hash>::Iterator<TRef, TableRef>:: inline Foam::StaticHashTable<T, Key, Hash>::Iterator<TRef, TableRef>::Iterator
Iterator
( (
TableRef curStaticHashTable, TableRef hashTbl,
label hashIndex, label hashIndex,
label elementIndex label elemIndex
) )
: :
curStaticHashTable_(curStaticHashTable), hashTable_(hashTbl),
hashIndex_(hashIndex), hashIndex_(hashIndex),
elementIndex_(elementIndex) elemIndex_(elemIndex)
{} {}
template<class T, class Key, class Hash> template<class T, class Key, class Hash>
template<class TRef, class TableRef> template<class TRef, class TableRef>
inline StaticHashTable<T, Key, Hash>::Iterator<TRef, TableRef>:: inline Foam::StaticHashTable<T, Key, Hash>::Iterator<TRef, TableRef>::Iterator
Iterator(const iterator& iter) (
const iterator& iter
)
: :
curStaticHashTable_(iter.curStaticHashTable_), hashTable_(iter.hashTable_),
hashIndex_(iter.hashIndex_), hashIndex_(iter.hashIndex_),
elementIndex_(iter.elementIndex_) elemIndex_(iter.elemIndex_)
{} {}
template<class T, class Key, class Hash> template<class T, class Key, class Hash>
template<class TRef, class TableRef> template<class TRef, class TableRef>
inline void StaticHashTable<T, Key, Hash>::Iterator<TRef, TableRef>:: inline void
operator=(const iterator& iter) Foam::StaticHashTable<T, Key, Hash>::Iterator<TRef, TableRef>::operator=
(
const iterator& iter
)
{ {
this->hashIndex_ = iter.hashIndex_; this->hashIndex_ = iter.hashIndex_;
this->elementIndex_ = iter.elementIndex_; this->elemIndex_ = iter.elemIndex_;
} }
template<class T, class Key, class Hash> template<class T, class Key, class Hash>
template<class TRef, class TableRef> template<class TRef, class TableRef>
inline bool StaticHashTable<T, Key, Hash>::Iterator<TRef, TableRef>:: inline bool
operator==(const iterator& iter) const Foam::StaticHashTable<T, Key, Hash>::Iterator<TRef, TableRef>::operator==
(
const iterator& iter
) const
{ {
return hashIndex_ == iter.hashIndex_ && elementIndex_ == iter.elementIndex_; return hashIndex_ == iter.hashIndex_ && elemIndex_ == iter.elemIndex_;
} }
template<class T, class Key, class Hash> template<class T, class Key, class Hash>
template<class TRef, class TableRef> template<class TRef, class TableRef>
inline bool StaticHashTable<T, Key, Hash>::Iterator<TRef, TableRef>:: inline bool
operator==(const const_iterator& iter) const Foam::StaticHashTable<T, Key, Hash>::Iterator<TRef, TableRef>::operator==
(
const const_iterator& iter
) const
{ {
return hashIndex_ == iter.hashIndex_ && elementIndex_ == iter.elementIndex_; return hashIndex_ == iter.hashIndex_ && elemIndex_ == iter.elemIndex_;
} }
template<class T, class Key, class Hash> template<class T, class Key, class Hash>
template<class TRef, class TableRef> template<class TRef, class TableRef>
inline bool StaticHashTable<T, Key, Hash>::Iterator<TRef, TableRef>:: inline bool
operator!=(const iterator& iter) const Foam::StaticHashTable<T, Key, Hash>::Iterator<TRef, TableRef>::operator!=
{ (
return !operator==(iter); const iterator& iter
} ) const
template<class T, class Key, class Hash>
template<class TRef, class TableRef>
inline bool StaticHashTable<T, Key, Hash>::Iterator<TRef, TableRef>::
operator!=(const const_iterator& iter) const
{ {
return !operator==(iter); return !operator==(iter);
} }
@ -156,17 +225,29 @@ operator!=(const const_iterator& iter) const
template<class T, class Key, class Hash> template<class T, class Key, class Hash>
template<class TRef, class TableRef> template<class TRef, class TableRef>
inline TRef StaticHashTable<T, Key, Hash>::Iterator<TRef, TableRef>:: inline bool
operator*() Foam::StaticHashTable<T, Key, Hash>::Iterator<TRef, TableRef>::operator!=
(
const const_iterator& iter
) const
{ {
return curStaticHashTable_.objects_[hashIndex_][elementIndex_]; return !operator==(iter);
} }
template<class T, class Key, class Hash> template<class T, class Key, class Hash>
template<class TRef, class TableRef> template<class TRef, class TableRef>
inline TRef StaticHashTable<T, Key, Hash>::Iterator<TRef, TableRef>:: inline TRef
operator()() Foam::StaticHashTable<T, Key, Hash>::Iterator<TRef, TableRef>::operator*()
{
return hashTable_.objects_[hashIndex_][elemIndex_];
}
template<class T, class Key, class Hash>
template<class TRef, class TableRef>
inline TRef
Foam::StaticHashTable<T, Key, Hash>::Iterator<TRef, TableRef>::operator()()
{ {
return operator*(); return operator*();
} }
@ -175,40 +256,44 @@ operator()()
template<class T, class Key, class Hash> template<class T, class Key, class Hash>
template<class TRef, class TableRef> template<class TRef, class TableRef>
inline inline
typename StaticHashTable<T, Key, Hash>::template Iterator typename Foam::StaticHashTable<T, Key, Hash>::template Iterator
< <
TRef, TRef,
TableRef TableRef
>& >&
StaticHashTable<T, Key, Hash>::Iterator Foam::StaticHashTable<T, Key, Hash>::Iterator
< <
TRef, TRef,
TableRef TableRef
>::operator++() >::operator++()
{ {
const List<T>& localObjects = curStaticHashTable_.objects_[hashIndex_]; // Check for special value from erase. (sets hashIndex to -1)
if (hashIndex_ >= 0)
if (elementIndex_ == localObjects.size()-1)
{ {
elementIndex_ = 0; // Try the next element on the local list
elemIndex_++;
// Find first non-zero entry if (elemIndex_ < hashTable_.objects_[hashIndex_].size())
for
(
hashIndex_++;
hashIndex_ < curStaticHashTable_.objects_.size();
hashIndex_++
)
{ {
if (curStaticHashTable_.objects_[hashIndex_].size() > 0) return *this;
{
break;
}
} }
} }
else
// Step to the next table entry
elemIndex_ = 0;
while
(
++hashIndex_ < hashTable_.objects_.size()
&& !hashTable_.objects_[hashIndex_].size()
)
{}
if (hashIndex_ >= hashTable_.objects_.size())
{ {
elementIndex_++; // make end iterator
hashIndex_ = hashTable_.keys_.size();
} }
return *this; return *this;
@ -218,12 +303,12 @@ StaticHashTable<T, Key, Hash>::Iterator
template<class T, class Key, class Hash> template<class T, class Key, class Hash>
template<class TRef, class TableRef> template<class TRef, class TableRef>
inline inline
typename StaticHashTable<T, Key, Hash>::template Iterator typename Foam::StaticHashTable<T, Key, Hash>::template Iterator
< <
TRef, TRef,
TableRef TableRef
> >
StaticHashTable<T, Key, Hash>::Iterator Foam::StaticHashTable<T, Key, Hash>::Iterator
< <
TRef, TRef,
TableRef TableRef
@ -240,24 +325,23 @@ StaticHashTable<T, Key, Hash>::Iterator
template<class T, class Key, class Hash> template<class T, class Key, class Hash>
template<class TRef, class TableRef> template<class TRef, class TableRef>
inline inline const Key&
const Key& StaticHashTable<T, Key, Hash>::Iterator<TRef, TableRef>:: Foam::StaticHashTable<T, Key, Hash>::Iterator<TRef, TableRef>::key() const
key()
{ {
return curStaticHashTable_.keys_[hashIndex_][elementIndex_]; return hashTable_.keys_[hashIndex_][elemIndex_];
} }
template<class T, class Key, class Hash> template<class T, class Key, class Hash>
inline typename StaticHashTable<T, Key, Hash>::iterator inline typename Foam::StaticHashTable<T, Key, Hash>::iterator
StaticHashTable<T, Key, Hash>::begin() Foam::StaticHashTable<T, Key, Hash>::begin()
{ {
// Find first non-empty entry // Find first non-empty entry
forAll(keys_, i) forAll(keys_, hashIdx)
{ {
if (keys_[i].size() > 0) if (keys_[hashIdx].size())
{ {
return iterator(*this, i, 0); return iterator(*this, hashIdx, 0);
} }
} }
@ -273,23 +357,23 @@ StaticHashTable<T, Key, Hash>::begin()
template<class T, class Key, class Hash> template<class T, class Key, class Hash>
inline const typename StaticHashTable<T, Key, Hash>::iterator& inline const typename Foam::StaticHashTable<T, Key, Hash>::iterator&
StaticHashTable<T, Key, Hash>::end() Foam::StaticHashTable<T, Key, Hash>::end()
{ {
return StaticHashTable<T, Key, Hash>::endIter_; return StaticHashTable<T, Key, Hash>::endIter_;
} }
template<class T, class Key, class Hash> template<class T, class Key, class Hash>
inline typename StaticHashTable<T, Key, Hash>::const_iterator inline typename Foam::StaticHashTable<T, Key, Hash>::const_iterator
StaticHashTable<T, Key, Hash>::begin() const Foam::StaticHashTable<T, Key, Hash>::cbegin() const
{ {
// Find first non-empty entry // Find first non-empty entry
forAll(keys_, i) forAll(keys_, hashIdx)
{ {
if (keys_[i].size() > 0) if (keys_[hashIdx].size())
{ {
return const_iterator(*this, i, 0); return const_iterator(*this, hashIdx, 0);
} }
} }
@ -305,8 +389,24 @@ StaticHashTable<T, Key, Hash>::begin() const
template<class T, class Key, class Hash> template<class T, class Key, class Hash>
inline const typename StaticHashTable<T, Key, Hash>::const_iterator& inline const typename Foam::StaticHashTable<T, Key, Hash>::const_iterator&
StaticHashTable<T, Key, Hash>::end() const Foam::StaticHashTable<T, Key, Hash>::cend() const
{
return StaticHashTable<T, Key, Hash>::endConstIter_;
}
template<class T, class Key, class Hash>
inline typename Foam::StaticHashTable<T, Key, Hash>::const_iterator
Foam::StaticHashTable<T, Key, Hash>::begin() const
{
return this->cbegin();
}
template<class T, class Key, class Hash>
inline const typename Foam::StaticHashTable<T, Key, Hash>::const_iterator&
Foam::StaticHashTable<T, Key, Hash>::end() const
{ {
return StaticHashTable<T, Key, Hash>::endConstIter_; return StaticHashTable<T, Key, Hash>::endConstIter_;
} }
@ -314,6 +414,4 @@ StaticHashTable<T, Key, Hash>::end() const
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// ************************************************************************* // // ************************************************************************* //

86
src/OpenFOAM/containers/HashTables/StaticHashTable/StaticHashTableIO.C
View file

@ -28,16 +28,14 @@ License
#include "Istream.H" #include "Istream.H"
#include "Ostream.H" #include "Ostream.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
// Construct from Istream
template<class T, class Key, class Hash> template<class T, class Key, class Hash>
StaticHashTable<T, Key, Hash>::StaticHashTable(Istream& is, const label size) Foam::StaticHashTable<T, Key, Hash>::StaticHashTable
(
Istream& is,
const label size
)
: :
StaticHashTableName(), StaticHashTableName(),
keys_(size), keys_(size),
@ -59,23 +57,58 @@ StaticHashTable<T, Key, Hash>::StaticHashTable(Istream& is, const label size)
} }
// * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * * //
template<class T, class Key, class Hash>
Foam::Ostream&
Foam::StaticHashTable<T, Key, Hash>::printInfo(Ostream& os) const
{
label used = 0;
label maxChain = 0;
unsigned avgChain = 0;
// Find first non-empty entry
forAll(keys_, hashIdx)
{
const label count = keys_[hashIdx].size();
if (count)
{
++used;
avgChain += count;
if (maxChain < count)
{
maxChain = count;
}
}
}
os << "StaticHashTable<T,Key,Hash>"
<< " elements:" << size() << " slots:" << used << "/" << keys_.size()
<< " chaining(avg/max):" << (used ? float(avgChain/used) : 0)
<< "/" << maxChain << endl;
return os;
}
// * * * * * * * * * * * * * * * IOstream Operators * * * * * * * * * * * * // // * * * * * * * * * * * * * * * IOstream Operators * * * * * * * * * * * * //
template<class T, class Key, class Hash> template<class T, class Key, class Hash>
Istream& operator>>(Istream& is, StaticHashTable<T, Key, Hash>& L) Foam::Istream& Foam::operator>>(Istream& is, StaticHashTable<T, Key, Hash>& L)
{ {
is.fatalCheck("operator>>(Istream&, StaticHashTable<T, Key, Hash>&)"); is.fatalCheck("operator>>(Istream&, StaticHashTable<T, Key, Hash>&)");
// Anull list // Anull list
L.clear(); L.clear();
is.fatalCheck("operator>>(Istream& is, StaticHashTable<T, Key, Hash>& L)"); is.fatalCheck("operator>>(Istream&, StaticHashTable<T, Key, Hash>&)");
token firstToken(is); token firstToken(is);
is.fatalCheck is.fatalCheck
( (
"operator>>(Istream& is, StaticHashTable<T, Key, Hash>& L) : " "operator>>(Istream&, StaticHashTable<T, Key, Hash>&) : "
"reading first token" "reading first token"
); );
@ -84,7 +117,7 @@ Istream& operator>>(Istream& is, StaticHashTable<T, Key, Hash>& L)
label s = firstToken.labelToken(); label s = firstToken.labelToken();
// Read beginning of contents // Read beginning of contents
char listDelimiter = is.readBeginList("StaticHashTable<T, Key, Hash>"); char delimiter = is.readBeginList("StaticHashTable<T, Key, Hash>");
if (s) if (s)
{ {
@ -93,7 +126,7 @@ Istream& operator>>(Istream& is, StaticHashTable<T, Key, Hash>& L)
L.resize(2*s); L.resize(2*s);
} }
if (listDelimiter == token::BEGIN_LIST) if (delimiter == token::BEGIN_LIST)
{ {
for (label i=0; i<s; i++) for (label i=0; i<s; i++)
{ {
@ -112,7 +145,7 @@ Istream& operator>>(Istream& is, StaticHashTable<T, Key, Hash>& L)
{ {
FatalIOErrorIn FatalIOErrorIn
( (
"operator>>(Istream& is, StaticHashTable<T, Key, Hash>& L)", "operator>>(Istream&, StaticHashTable<T, Key, Hash>&)",
is is
) << "incorrect first token, '(', found " << firstToken.info() ) << "incorrect first token, '(', found " << firstToken.info()
<< exit(FatalIOError); << exit(FatalIOError);
@ -128,7 +161,7 @@ Istream& operator>>(Istream& is, StaticHashTable<T, Key, Hash>& L)
{ {
FatalIOErrorIn FatalIOErrorIn
( (
"operator>>(Istream& is, StaticHashTable<T, Key, Hash>& L)", "operator>>(Istream&, StaticHashTable<T, Key, Hash>&)",
is is
) << "incorrect first token, '(', found " << firstToken.info() ) << "incorrect first token, '(', found " << firstToken.info()
<< exit(FatalIOError); << exit(FatalIOError);
@ -144,10 +177,13 @@ Istream& operator>>(Istream& is, StaticHashTable<T, Key, Hash>& L)
) )
{ {
is.putBack(lastToken); is.putBack(lastToken);
Key key; Key key;
is >> key; is >> key;
T element; T element;
is >> element; is >> element;
L.insert(key, element); L.insert(key, element);
is.fatalCheck is.fatalCheck
@ -163,7 +199,7 @@ Istream& operator>>(Istream& is, StaticHashTable<T, Key, Hash>& L)
{ {
FatalIOErrorIn FatalIOErrorIn
( (
"operator>>(Istream& is, StaticHashTable<T, Key, Hash>& L)", "operator>>(Istream&, StaticHashTable<T, Key, Hash>&)",
is is
) << "incorrect first token, expected <int> or '(', found " ) << "incorrect first token, expected <int> or '(', found "
<< firstToken.info() << firstToken.info()
@ -177,15 +213,15 @@ Istream& operator>>(Istream& is, StaticHashTable<T, Key, Hash>& L)
template<class T, class Key, class Hash> template<class T, class Key, class Hash>
Ostream& operator<<(Ostream& os, const StaticHashTable<T, Key, Hash>& L) Foam::Ostream& Foam::operator<<
(
Ostream& os,
const StaticHashTable<T, Key, Hash>& L)
{ {
// Write size of StaticHashTable // Write size and start delimiter
os << nl << L.size(); os << nl << L.size() << nl << token::BEGIN_LIST << nl;
// Write beginning of contents // Write contents
os << nl << token::BEGIN_LIST << nl;
// Write StaticHashTable contents
for for
( (
typename StaticHashTable<T, Key, Hash>::const_iterator iter = L.begin(); typename StaticHashTable<T, Key, Hash>::const_iterator iter = L.begin();
@ -196,7 +232,7 @@ Ostream& operator<<(Ostream& os, const StaticHashTable<T, Key, Hash>& L)
os << iter.key() << token::SPACE << iter() << nl; os << iter.key() << token::SPACE << iter() << nl;
} }
// Write end of contents // Write end delimiter
os << token::END_LIST; os << token::END_LIST;
// Check state of IOstream // Check state of IOstream
@ -206,8 +242,4 @@ Ostream& operator<<(Ostream& os, const StaticHashTable<T, Key, Hash>& L)
} }
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// ************************************************************************* // // ************************************************************************* //

132
src/OpenFOAM/containers/Identifiers/Keyed/Keyed.H Normal file
View file

@ -0,0 +1,132 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright held by original author
\\/ M anipulation |
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
OpenFOAM is free software; you can redistribute it and/or modify it
under the terms of the GNU General Public License as published by the
Free Software Foundation; either version 2 of the License, or (at your
option) any later version.
OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
for more details.
You should have received a copy of the GNU General Public License
along with OpenFOAM; if not, write to the Free Software Foundation,
Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
Class
Foam::Keyed
Description
A container with an integer key attached to any item.
The key can useful for sorting.
SourceFiles
KeyedI.H
\*---------------------------------------------------------------------------*/
#ifndef Keyed_H
#define Keyed_H
#include "List.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
// Forward declaration of friend functions and operators
template<class T> class Keyed;
template<class T> Istream& operator>>(Istream&, Keyed<T>&);
template<class T> Ostream& operator<<(Ostream&, const Keyed<T>&);
/*---------------------------------------------------------------------------*\
Class Keyed Declaration
\*---------------------------------------------------------------------------*/
template<class T>
class Keyed
:
public T
{
// Private data
label key_;
public:
// Static Members
//- Add labels to a list of values
inline static List<Keyed<T> > createList
(
const List<T>&,
const label key=0
);
//- Add labels to a list of values
inline static List<Keyed<T> > createList
(
const List<T>&,
const List<label>& keys
);
// Constructors
//- Construct null
inline Keyed();
//- Construct as a copy of item, with a key
inline Keyed(const T& item, const label key=0);
//- Construct by transferring the item, with a key
inline Keyed(const Xfer<T>& item, const label key=0);
//- Construct from Istream
inline Keyed(Istream&);
// Member Functions
// Access
//- Return const access to the integer key
inline label key() const;
//- Return non-const access to the integer key
inline label& key();
// IOstream Operators
friend Istream& operator>> <T>(Istream&, Keyed<T>&);
friend Ostream& operator<< <T>(Ostream&, const Keyed<T>&);
};
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#include "KeyedI.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //

152
src/OpenFOAM/containers/Identifiers/Keyed/KeyedI.H Normal file
View file

@ -0,0 +1,152 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright held by original author
\\/ 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 "IOstreams.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
template<class T>
inline Foam::Keyed<T>::Keyed()
:
key_(-1)
{}
template<class T>
inline Foam::Keyed<T>::Keyed(const T& item, const label key)
:
T(item),
key_(key)
{}
template<class T>
inline Foam::Keyed<T>::Keyed(const Xfer<T>& item, const label key)
:
T(item),
key_(key)
{}
template<class T>
inline Foam::Keyed<T>::Keyed(Istream& is)
{
is >> *this;
}
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
template<class T>
inline Foam::label Foam::Keyed<T>::key() const
{
return key_;
}
template<class T>
inline Foam::label& Foam::Keyed<T>::key()
{
return key_;
}
template<class T>
inline Foam::List<Foam::Keyed<T> >
Foam::Keyed<T>::createList(const List<T>& lst, const label key)
{
List<Keyed<T> > newList(lst.size());
forAll (lst, elemI)
{
newList[elemI] = Keyed(lst[elemI], key);
}
return newList;
}
template<class T>
inline Foam::List<Foam::Keyed<T> >
Foam::Keyed<T>::createList(const List<T>& lst, const List<label>& keys)
{
if (lst.size() != keys.size())
{
FatalErrorIn
(
"Foam::Keyed<T>::createList(const List<T>&, const List<label>&)"
)
<< "size mismatch adding keys to a list:" << nl
<< "List has size " << lst.size()
<< " and keys has size " << keys.size() << nl
<< abort(FatalError);
}
List<Keyed<T> > newList(lst.size());
forAll (lst, elemI)
{
newList[elemI] = Keyed(lst[elemI], keys[elemI]);
}
return newList;
}
// * * * * * * * * * * * * * * * Ostream Operator * * * * * * * * * * * * * //
template<class T>
inline Foam::Istream& Foam::operator>>(Istream& is, Keyed<T>& item)
{
// Read beginning of Keyed item/key pair
is.readBegin("Keyed<T>");
is >> static_cast<T&>(item);
is >> item.key_;
// Read end of Keyed item/key pair
is.readEnd("Keyed<T>");
// Check state of Ostream
is.check("Istream& operator>>(Istream&, Keyed&)");
return is;
}
template<class T>
inline Foam::Ostream& Foam::operator<<(Ostream& os, const Keyed<T>& item)
{
os << token::BEGIN_LIST
<< static_cast<const T&>(item)
<< token::SPACE << item.key_
<< token::END_LIST;
return os;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
// ************************************************************************* //

48
src/OpenFOAM/containers/LinkedLists/accessTypes/ILList/ILList.C
View file

@ -26,22 +26,17 @@ License
#include "ILList.H" #include "ILList.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
template<class LListBase, class T> template<class LListBase, class T>
ILList<LListBase, T>::ILList(const ILList<LListBase, T>& slpl) Foam::ILList<LListBase, T>::ILList(const ILList<LListBase, T>& lst)
: :
UILList<LListBase, T>() UILList<LListBase, T>()
{ {
for for
( (
typename UILList<LListBase, T>::const_iterator iter = slpl.begin(); typename UILList<LListBase, T>::const_iterator iter = lst.begin();
iter != slpl.end(); iter != lst.end();
++iter ++iter
) )
{ {
@ -53,9 +48,9 @@ ILList<LListBase, T>::ILList(const ILList<LListBase, T>& slpl)
#ifndef __INTEL_COMPILER #ifndef __INTEL_COMPILER
template<class LListBase, class T> template<class LListBase, class T>
template<class CloneArg> template<class CloneArg>
ILList<LListBase, T>::ILList Foam::ILList<LListBase, T>::ILList
( (
const ILList<LListBase, T>& slpl, const ILList<LListBase, T>& lst,
const CloneArg& cloneArg const CloneArg& cloneArg
) )
: :
@ -63,8 +58,8 @@ ILList<LListBase, T>::ILList
{ {
for for
( (
typename UILList<LListBase, T>::const_iterator iter = slpl.begin(); typename UILList<LListBase, T>::const_iterator iter = lst.begin();
iter != slpl.end(); iter != lst.end();
++iter ++iter
) )
{ {
@ -77,7 +72,7 @@ ILList<LListBase, T>::ILList
// * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * * //
template<class LListBase, class T> template<class LListBase, class T>
ILList<LListBase, T>::~ILList() Foam::ILList<LListBase, T>::~ILList()
{ {
this->clear(); this->clear();
} }
@ -85,9 +80,8 @@ ILList<LListBase, T>::~ILList()
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
//- Return and remove head
template<class LListBase, class T> template<class LListBase, class T>
bool ILList<LListBase, T>::eraseHead() bool Foam::ILList<LListBase, T>::eraseHead()
{ {
T* tPtr; T* tPtr;
if ((tPtr = this->removeHead())) if ((tPtr = this->removeHead()))
@ -101,9 +95,8 @@ bool ILList<LListBase, T>::eraseHead()
} }
} }
//- Return and remove element
template<class LListBase, class T> template<class LListBase, class T>
bool ILList<LListBase, T>::erase(T* p) bool Foam::ILList<LListBase, T>::erase(T* p)
{ {
T* tPtr; T* tPtr;
if ((tPtr = remove(p))) if ((tPtr = remove(p)))
@ -119,7 +112,7 @@ bool ILList<LListBase, T>::erase(T* p)
template<class LListBase, class T> template<class LListBase, class T>
void ILList<LListBase, T>::clear() void Foam::ILList<LListBase, T>::clear()
{ {
label oldSize = this->size(); label oldSize = this->size();
for (label i=0; i<oldSize; i++) for (label i=0; i<oldSize; i++)
@ -131,17 +124,25 @@ void ILList<LListBase, T>::clear()
} }
template<class LListBase, class T>
void Foam::ILList<LListBase, T>::transfer(ILList<LListBase, T>& lst)
{
clear();
LListBase::transfer(lst);
}
// * * * * * * * * * * * * * * * Member Operators * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * Member Operators * * * * * * * * * * * * * //
template<class LListBase, class T> template<class LListBase, class T>
void ILList<LListBase, T>::operator=(const ILList<LListBase, T>& slpl) void Foam::ILList<LListBase, T>::operator=(const ILList<LListBase, T>& lst)
{ {
this->clear(); this->clear();
for for
( (
typename UILList<LListBase, T>::const_iterator iter = slpl.begin(); typename UILList<LListBase, T>::const_iterator iter = lst.begin();
iter != slpl.end(); iter != lst.end();
++iter ++iter
) )
{ {
@ -149,11 +150,6 @@ void ILList<LListBase, T>::operator=(const ILList<LListBase, T>& slpl)
} }
} }
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// * * * * * * * * * * * * * * * Friend Operators * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * Friend Operators * * * * * * * * * * * * * //
#include "ILListIO.C" #include "ILListIO.C"

19
src/OpenFOAM/containers/LinkedLists/accessTypes/ILList/ILList.H
View file

@ -71,7 +71,7 @@ class ILList
//- Read from Istream using given Istream constructor class //- Read from Istream using given Istream constructor class
template<class INew> template<class INew>
void read(Istream&, const INew& inewt); void read(Istream&, const INew&);
public: public:
@ -96,7 +96,7 @@ public:
//- Copy constructor with additional argument for clone //- Copy constructor with additional argument for clone
template<class CloneArg> template<class CloneArg>
ILList(const ILList<LListBase, T>& slpl, const CloneArg& cloneArg) ILList(const ILList<LListBase, T>& lst, const CloneArg& cloneArg)
#ifdef __INTEL_COMPILER #ifdef __INTEL_COMPILER
: :
UILList<LListBase, T>() UILList<LListBase, T>()
@ -104,8 +104,8 @@ public:
for for
( (
typename UILList<LListBase, T>::const_iterator iter = typename UILList<LListBase, T>::const_iterator iter =
slpl.begin(); lst.begin();
iter != slpl.end(); iter != lst.end();
++iter ++iter
) )
{ {
@ -118,7 +118,7 @@ public:
//- Construct from Istream using given Istream constructor class //- Construct from Istream using given Istream constructor class
template<class INew> template<class INew>
ILList(Istream&, const INew& inewt); ILList(Istream&, const INew&);
// Destructor // Destructor
@ -139,6 +139,10 @@ public:
//- Clear the contents of the list //- Clear the contents of the list
void clear(); void clear();
//- Transfer the contents of the argument into this List
// and annull the argument list.
void transfer(ILList<LListBase, T>&);
// Member operators // Member operators
@ -148,10 +152,7 @@ public:
// Istream operator // Istream operator
//- Read List from Istream, discarding contents of existing List. //- Read List from Istream, discarding contents of existing List.
friend Istream& operator>> friend Istream& operator>> <LListBase, T>
#ifndef __CINT__
<LListBase, T>
#endif
( (
Istream&, Istream&,
ILList<LListBase, T>& ILList<LListBase, T>&

47
src/OpenFOAM/containers/LinkedLists/accessTypes/ILList/ILListIO.C
View file

@ -30,24 +30,19 @@ Description
#include "Istream.H" #include "Istream.H"
#include "INew.H" #include "INew.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
template<class LListBase, class T> template<class LListBase, class T>
template<class INew> template<class INew>
void ILList<LListBase, T>::read(Istream& is, const INew& inewt) void Foam::ILList<LListBase, T>::read(Istream& is, const INew& iNew)
{ {
is.fatalCheck("operator>>(Istream& is, ILList<LListBase, T>& L)"); is.fatalCheck("operator>>(Istream&, ILList<LListBase, T>&)");
token firstToken(is); token firstToken(is);
is.fatalCheck is.fatalCheck
( (
"operator>>(Istream& is, ILList<LListBase, T>& L) : reading first token" "operator>>(Istream&, ILList<LListBase, T>&) : reading first token"
); );
if (firstToken.isLabel()) if (firstToken.isLabel())
@ -55,31 +50,31 @@ void ILList<LListBase, T>::read(Istream& is, const INew& inewt)
label s = firstToken.labelToken(); label s = firstToken.labelToken();
// Read beginning of contents // Read beginning of contents
char listDelimiter = is.readBeginList("ILList<LListBase, T>"); char delimiter = is.readBeginList("ILList<LListBase, T>");
if (s) if (s)
{ {
if (listDelimiter == token::BEGIN_LIST) if (delimiter == token::BEGIN_LIST)
{ {
for (label i=0; i<s; i++) for (label i=0; i<s; i++)
{ {
append(inewt(is).ptr()); append(iNew(is).ptr());
is.fatalCheck is.fatalCheck
( (
"operator>>(Istream& is, ILList<LListBase, T>& L) : " "operator>>(Istream&, ILList<LListBase, T>&) : "
"reading entry" "reading entry"
); );
} }
} }
else else
{ {
T* tPtr = inewt(is).ptr(); T* tPtr = iNew(is).ptr();
append(tPtr); append(tPtr);
is.fatalCheck is.fatalCheck
( (
"operator>>(Istream& is, ILList<LListBase, T>& L) : " "operator>>(Istream&, ILList<LListBase, T>&) : "
"reading entry" "reading entry"
); );
@ -99,14 +94,14 @@ void ILList<LListBase, T>::read(Istream& is, const INew& inewt)
{ {
FatalIOErrorIn FatalIOErrorIn
( (
"operator>>(Istream& is, ILList<LListBase, T>& L)", "operator>>(Istream&, ILList<LListBase, T>&)",
is is
) << "incorrect first token, '(', found " << firstToken.info() ) << "incorrect first token, '(', found " << firstToken.info()
<< exit(FatalIOError); << exit(FatalIOError);
} }
token lastToken(is); token lastToken(is);
is.fatalCheck("operator>>(Istream& is, ILList<LListBase, T>& L)"); is.fatalCheck("operator>>(Istream&, ILList<LListBase, T>&)");
while while
( (
@ -117,36 +112,34 @@ void ILList<LListBase, T>::read(Istream& is, const INew& inewt)
) )
{ {
is.putBack(lastToken); is.putBack(lastToken);
append(inewt(is).ptr()); append(iNew(is).ptr());
is >> lastToken; is >> lastToken;
is.fatalCheck("operator>>(Istream& is, ILList<LListBase, T>& L)"); is.fatalCheck("operator>>(Istream&, ILList<LListBase, T>&)");
} }
} }
else else
{ {
FatalIOErrorIn("operator>>(Istream& is, ILList<LListBase, T>& L)", is) FatalIOErrorIn("operator>>(Istream&, ILList<LListBase, T>&)", is)
<< "incorrect first token, expected <int> or '(', found " << "incorrect first token, expected <int> or '(', found "
<< firstToken.info() << firstToken.info()
<< exit(FatalIOError); << exit(FatalIOError);
} }
is.fatalCheck("operator>>(Istream& is, ILList<LListBase, T>& L)"); is.fatalCheck("operator>>(Istream&, ILList<LListBase, T>&)");
} }
//- Construct from Istream using given Istream constructor class
template<class LListBase, class T> template<class LListBase, class T>
template<class INew> template<class INew>
ILList<LListBase, T>::ILList(Istream& is, const INew& inewt) Foam::ILList<LListBase, T>::ILList(Istream& is, const INew& iNew)
{ {
read(is, inewt); read(is, iNew);
} }
// Construct from Istream
template<class LListBase, class T> template<class LListBase, class T>
ILList<LListBase, T>::ILList(Istream& is) Foam::ILList<LListBase, T>::ILList(Istream& is)
{ {
read(is, INew<T>()); read(is, INew<T>());
} }
@ -155,7 +148,7 @@ ILList<LListBase, T>::ILList(Istream& is)
// * * * * * * * * * * * * * * * Istream Operator * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * Istream Operator * * * * * * * * * * * * * //
template<class LListBase, class T> template<class LListBase, class T>
Istream& operator>>(Istream& is, ILList<LListBase, T>& L) Foam::Istream& Foam::operator>>(Istream& is, ILList<LListBase, T>& L)
{ {
L.clear(); L.clear();
L.read(is, INew<T>()); L.read(is, INew<T>());
@ -166,6 +159,4 @@ Istream& operator>>(Istream& is, ILList<LListBase, T>& L)
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// ************************************************************************* // // ************************************************************************* //

30
src/OpenFOAM/containers/LinkedLists/accessTypes/LList/LList.C
View file

@ -27,22 +27,16 @@ Description
\*---------------------------------------------------------------------------*/ \*---------------------------------------------------------------------------*/
#include "error.H" #include "error.H"
#include "LList.H" #include "LList.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
template<class LListBase, class T> template<class LListBase, class T>
LList<LListBase, T>::LList(const LList<LListBase, T>& slpl) Foam::LList<LListBase, T>::LList(const LList<LListBase, T>& lst)
: :
LListBase() LListBase()
{ {
for (const_iterator iter = slpl.begin(); iter != slpl.end(); ++iter) for (const_iterator iter = lst.begin(); iter != lst.end(); ++iter)
{ {
append(iter()); append(iter());
} }
@ -50,7 +44,7 @@ LList<LListBase, T>::LList(const LList<LListBase, T>& slpl)
template<class LListBase, class T> template<class LListBase, class T>
LList<LListBase, T>::~LList() Foam::LList<LListBase, T>::~LList()
{ {
this->clear(); this->clear();
} }
@ -59,7 +53,7 @@ LList<LListBase, T>::~LList()
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
template<class LListBase, class T> template<class LListBase, class T>
void LList<LListBase, T>::clear() void Foam::LList<LListBase, T>::clear()
{ {
label oldSize = this->size(); label oldSize = this->size();
for (label i=0; i<oldSize; i++) for (label i=0; i<oldSize; i++)
@ -71,24 +65,28 @@ void LList<LListBase, T>::clear()
} }
template<class LListBase, class T>
void Foam::LList<LListBase, T>::transfer(LList<LListBase, T>& lst)
{
clear();
LListBase::transfer(lst);
}
// * * * * * * * * * * * * * * * Member Operators * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * Member Operators * * * * * * * * * * * * * //
template<class LListBase, class T> template<class LListBase, class T>
void LList<LListBase, T>::operator=(const LList<LListBase, T>& slpl) void Foam::LList<LListBase, T>::operator=(const LList<LListBase, T>& lst)
{ {
this->clear(); this->clear();
for (const_iterator iter = slpl.begin(); iter != slpl.end(); ++iter) for (const_iterator iter = lst.begin(); iter != lst.end(); ++iter)
{ {
append(iter()); append(iter());
} }
} }
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// * * * * * * * * * * * * * * * Friend Operators * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * Friend Operators * * * * * * * * * * * * * //
#include "LListIO.C" #include "LListIO.C"

16
src/OpenFOAM/containers/LinkedLists/accessTypes/LList/LList.H
View file

@ -38,6 +38,7 @@ SourceFiles
#define LList_H #define LList_H
#include "label.H" #include "label.H"
#include "uLabel.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
@ -67,7 +68,7 @@ Ostream& operator<<
/*---------------------------------------------------------------------------*\ /*---------------------------------------------------------------------------*\
Class LList Declaration Class LList Declaration
\*---------------------------------------------------------------------------*/ \*---------------------------------------------------------------------------*/
template<class LListBase, class T> template<class LListBase, class T>
@ -200,6 +201,9 @@ public:
//- Delete contents of list //- Delete contents of list
void clear(); void clear();
//- Transfer the contents of the argument into this List
// and annull the argument list.
void transfer(LList<LListBase, T>&);
// Member operators // Member operators
@ -323,19 +327,13 @@ public:
// IOstream operators // IOstream operators
friend Istream& operator>> friend Istream& operator>> <LListBase, T>
#ifndef __CINT__
<LListBase, T>
#endif
( (
Istream&, Istream&,
LList<LListBase, T>& LList<LListBase, T>&
); );
friend Ostream& operator<< friend Ostream& operator<< <LListBase, T>
#ifndef __CINT__
<LListBase, T>
#endif
( (
Ostream&, Ostream&,
const LList<LListBase, T>& const LList<LListBase, T>&

46
src/OpenFOAM/containers/LinkedLists/accessTypes/LList/LListIO.C
View file

@ -30,16 +30,10 @@ Description
#include "Istream.H" #include "Istream.H"
#include "Ostream.H" #include "Ostream.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
// Construct from Istream
template<class LListBase, class T> template<class LListBase, class T>
LList<LListBase, T>::LList(Istream& is) Foam::LList<LListBase, T>::LList(Istream& is)
{ {
operator>>(is, *this); operator>>(is, *this);
} }
@ -48,18 +42,18 @@ LList<LListBase, T>::LList(Istream& is)
// * * * * * * * * * * * * * * * Istream Operator * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * Istream Operator * * * * * * * * * * * * * //
template<class LListBase, class T> template<class LListBase, class T>
Istream& operator>>(Istream& is, LList<LListBase, T>& L) Foam::Istream& Foam::operator>>(Istream& is, LList<LListBase, T>& L)
{ {
// Anull list // Anull list
L.clear(); L.clear();
is.fatalCheck(" operator>>(Istream& is, LList<LListBase, T>& L)"); is.fatalCheck(" operator>>(Istream&, LList<LListBase, T>&)");
token firstToken(is); token firstToken(is);
is.fatalCheck is.fatalCheck
( (
" operator>>(Istream& is, LList<LListBase, T>& L) : reading first token" " operator>>(Istream&, LList<LListBase, T>&) : reading first token"
); );
if (firstToken.isLabel()) if (firstToken.isLabel())
@ -67,11 +61,11 @@ Istream& operator>>(Istream& is, LList<LListBase, T>& L)
label s = firstToken.labelToken(); label s = firstToken.labelToken();
// Read beginning of contents // Read beginning of contents
char listDelimiter = is.readBeginList("LList<LListBase, T>"); char delimiter = is.readBeginList("LList<LListBase, T>");
if (s) if (s)
{ {
if (listDelimiter == token::BEGIN_LIST) if (delimiter == token::BEGIN_LIST)
{ {
for (register label i=0; i<s; i++) for (register label i=0; i<s; i++)
{ {
@ -101,14 +95,14 @@ Istream& operator>>(Istream& is, LList<LListBase, T>& L)
{ {
FatalIOErrorIn FatalIOErrorIn
( (
" operator>>(Istream& is, LList<LListBase, T>& L)", " operator>>(Istream&, LList<LListBase, T>&)",
is is
) << "incorrect first token, '(', found " << firstToken.info() ) << "incorrect first token, '(', found " << firstToken.info()
<< exit(FatalIOError); << exit(FatalIOError);
} }
token lastToken(is); token lastToken(is);
is.fatalCheck(" operator>>(Istream& is, LList<LListBase, T>& L)"); is.fatalCheck(" operator>>(Istream&, LList<LListBase, T>&)");
while while
( (
@ -124,19 +118,19 @@ Istream& operator>>(Istream& is, LList<LListBase, T>& L)
L.append(element); L.append(element);
is >> lastToken; is >> lastToken;
is.fatalCheck(" operator>>(Istream& is, LList<LListBase, T>& L)"); is.fatalCheck(" operator>>(Istream&, LList<LListBase, T>&)");
} }
} }
else else
{ {
FatalIOErrorIn(" operator>>(Istream& is, LList<LListBase, T>& L)", is) FatalIOErrorIn(" operator>>(Istream&, LList<LListBase, T>&)", is)
<< "incorrect first token, expected <int> or '(', found " << "incorrect first token, expected <int> or '(', found "
<< firstToken.info() << firstToken.info()
<< exit(FatalIOError); << exit(FatalIOError);
} }
// Check state of IOstream // Check state of IOstream
is.fatalCheck(" operator>>(Istream& is, LList<LListBase, T>& L)"); is.fatalCheck(" operator>>(Istream&, LList<LListBase,>&)");
return is; return is;
} }
@ -145,19 +139,19 @@ Istream& operator>>(Istream& is, LList<LListBase, T>& L)
// * * * * * * * * * * * * * * * Ostream Operator * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * Ostream Operator * * * * * * * * * * * * * //
template<class LListBase, class T> template<class LListBase, class T>
Ostream& operator<<(Ostream& os, const LList<LListBase, T>& ll) Foam::Ostream& Foam::operator<<(Ostream& os, const LList<LListBase, T>& lst)
{ {
// Write size of LList // Write size
os << nl << ll.size(); os << nl << lst.size();
// Write beginning of contents // Write beginning of contents
os << nl << token::BEGIN_LIST << nl; os << nl << token::BEGIN_LIST << nl;
// Write LList contents // Write contents
for for
( (
typename LList<LListBase, T>::const_iterator iter = ll.begin(); typename LList<LListBase, T>::const_iterator iter = lst.begin();
iter != ll.end(); iter != lst.end();
++iter ++iter
) )
{ {
@ -168,14 +162,10 @@ Ostream& operator<<(Ostream& os, const LList<LListBase, T>& ll)
os << token::END_LIST; os << token::END_LIST;
// Check state of IOstream // Check state of IOstream
os.check("Ostream& operator<<(Ostream&, const LList&)"); os.check("Ostream& operator<<(Ostream&, const LList<LListBase, T>&)");
return os; return os;
} }
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// ************************************************************************* // // ************************************************************************* //

32
src/OpenFOAM/containers/LinkedLists/accessTypes/LPtrList/LPtrList.C
View file

@ -26,19 +26,14 @@ License
#include "LPtrList.H" #include "LPtrList.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
template<class LListBase, class T> template<class LListBase, class T>
LPtrList<LListBase, T>::LPtrList(const LPtrList<LListBase, T>& slpl) Foam::LPtrList<LListBase, T>::LPtrList(const LPtrList<LListBase, T>& lst)
: :
LList<LListBase, T*>() LList<LListBase, T*>()
{ {
for(const_iterator iter = slpl.begin(); iter != slpl.end(); ++iter) for (const_iterator iter = lst.begin(); iter != lst.end(); ++iter)
{ {
append(iter().clone().ptr()); append(iter().clone().ptr());
} }
@ -48,7 +43,7 @@ LPtrList<LListBase, T>::LPtrList(const LPtrList<LListBase, T>& slpl)
// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * //
template<class LListBase, class T> template<class LListBase, class T>
LPtrList<LListBase, T>::~LPtrList() Foam::LPtrList<LListBase, T>::~LPtrList()
{ {
clear(); clear();
} }
@ -56,9 +51,8 @@ LPtrList<LListBase, T>::~LPtrList()
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
//- Return and remove head
template<class LListBase, class T> template<class LListBase, class T>
bool LPtrList<LListBase, T>::eraseHead() bool Foam::LPtrList<LListBase, T>::eraseHead()
{ {
T* tPtr; T* tPtr;
if ((tPtr = this->removeHead())) if ((tPtr = this->removeHead()))
@ -74,7 +68,7 @@ bool LPtrList<LListBase, T>::eraseHead()
template<class LListBase, class T> template<class LListBase, class T>
void LPtrList<LListBase, T>::clear() void Foam::LPtrList<LListBase, T>::clear()
{ {
label oldSize = this->size(); label oldSize = this->size();
for (label i=0; i<oldSize; i++) for (label i=0; i<oldSize; i++)
@ -86,24 +80,28 @@ void LPtrList<LListBase, T>::clear()
} }
template<class LListBase, class T>
void Foam::LPtrList<LListBase, T>::transfer(LPtrList<LListBase, T>& lst)
{
clear();
LList<LListBase, T*>::transfer(lst);
}
// * * * * * * * * * * * * * * * Member Operators * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * Member Operators * * * * * * * * * * * * * //
template<class LListBase, class T> template<class LListBase, class T>
void LPtrList<LListBase, T>::operator=(const LPtrList<LListBase, T>& slpl) void Foam::LPtrList<LListBase, T>::operator=(const LPtrList<LListBase, T>& lst)
{ {
clear(); clear();
for(const_iterator iter = slpl.begin(); iter != slpl.end(); ++iter) for (const_iterator iter = lst.begin(); iter != lst.end(); ++iter)
{ {
append(iter().clone().ptr()); append(iter().clone().ptr());
} }
} }
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// * * * * * * * * * * * * * * * Friend Operators * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * Friend Operators * * * * * * * * * * * * * //
#include "LPtrListIO.C" #include "LPtrListIO.C"

18
src/OpenFOAM/containers/LinkedLists/accessTypes/LPtrList/LPtrList.H
View file

@ -149,12 +149,16 @@ public:
// Edit // Edit
//- Remove the head element specified from the list and delete it //- Remove the head element from the list and delete the pointer
bool eraseHead(); bool eraseHead();
//- Remove the specified element from the list and delete it //- Clear the contents of the list
void clear(); void clear();
//- Transfer the contents of the argument into this List
// and annull the argument list.
void transfer(LPtrList<LListBase, T>&);
// Member operators // Member operators
@ -256,19 +260,13 @@ public:
// IOstream operators // IOstream operators
friend Istream& operator>> friend Istream& operator>> <LListBase, T>
#ifndef __CINT__
<LListBase, T>
#endif
( (
Istream&, Istream&,
LPtrList<LListBase, T>& LPtrList<LListBase, T>&
); );
friend Ostream& operator<< friend Ostream& operator<< <LListBase, T>
#ifndef __CINT__
<LListBase, T>
#endif
( (
Ostream&, Ostream&,
const LPtrList<LListBase, T>& const LPtrList<LListBase, T>&

47
src/OpenFOAM/containers/LinkedLists/accessTypes/LPtrList/LPtrListIO.C
View file

@ -29,16 +29,11 @@ License
#include "Ostream.H" #include "Ostream.H"
#include "INew.H" #include "INew.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
// * * * * * * * * * * * * Private Member Functions * * * * * * * * * * * * // // * * * * * * * * * * * * Private Member Functions * * * * * * * * * * * * //
template<class LListBase, class T> template<class LListBase, class T>
template<class INew> template<class INew>
void LPtrList<LListBase, T>::read(Istream& is, const INew& inewt) void Foam::LPtrList<LListBase, T>::read(Istream& is, const INew& iNew)
{ {
is.fatalCheck is.fatalCheck
( (
@ -58,15 +53,15 @@ void LPtrList<LListBase, T>::read(Istream& is, const INew& inewt)
label s = firstToken.labelToken(); label s = firstToken.labelToken();
// Read beginning of contents // Read beginning of contents
char listDelimiter = is.readBeginList("LPtrList<LListBase, T>"); char delimiter = is.readBeginList("LPtrList<LListBase, T>");
if (s) if (s)
{ {
if (listDelimiter == token::BEGIN_LIST) if (delimiter == token::BEGIN_LIST)
{ {
for (label i=0; i<s; i++) for (label i=0; i<s; i++)
{ {
append(inewt(is).ptr()); append(iNew(is).ptr());
is.fatalCheck is.fatalCheck
( (
@ -77,7 +72,7 @@ void LPtrList<LListBase, T>::read(Istream& is, const INew& inewt)
} }
else else
{ {
T* tPtr = inewt(is).ptr(); T* tPtr = iNew(is).ptr();
append(tPtr); append(tPtr);
is.fatalCheck is.fatalCheck
@ -120,7 +115,7 @@ void LPtrList<LListBase, T>::read(Istream& is, const INew& inewt)
) )
{ {
is.putBack(lastToken); is.putBack(lastToken);
append(inewt(is).ptr()); append(iNew(is).ptr());
is >> lastToken; is >> lastToken;
is.fatalCheck is.fatalCheck
@ -148,14 +143,14 @@ void LPtrList<LListBase, T>::read(Istream& is, const INew& inewt)
template<class LListBase, class T> template<class LListBase, class T>
template<class INew> template<class INew>
LPtrList<LListBase, T>::LPtrList(Istream& is, const INew& inewt) Foam::LPtrList<LListBase, T>::LPtrList(Istream& is, const INew& iNew)
{ {
read(is, inewt); read(is, iNew);
} }
template<class LListBase, class T> template<class LListBase, class T>
LPtrList<LListBase, T>::LPtrList(Istream& is) Foam::LPtrList<LListBase, T>::LPtrList(Istream& is)
{ {
read(is, INew<T>()); read(is, INew<T>());
} }
@ -164,11 +159,10 @@ LPtrList<LListBase, T>::LPtrList(Istream& is)
// * * * * * * * * * * * * * * * Istream Operator * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * Istream Operator * * * * * * * * * * * * * //
template<class LListBase, class T> template<class LListBase, class T>
Istream& operator>>(Istream& is, LPtrList<LListBase, T>& L) Foam::Istream& Foam::operator>>(Istream& is, LPtrList<LListBase, T>& L)
{ {
// Anull list
L.clear(); L.clear();
L.read(is, INew<T>());
return is; return is;
} }
@ -177,19 +171,19 @@ Istream& operator>>(Istream& is, LPtrList<LListBase, T>& L)
// * * * * * * * * * * * * * * * Ostream Operators * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * Ostream Operators * * * * * * * * * * * * * //
template<class LListBase, class T> template<class LListBase, class T>
Ostream& operator<<(Ostream& os, const LPtrList<LListBase, T>& slpl) Foam::Ostream& Foam::operator<<(Ostream& os, const LPtrList<LListBase, T>& lst)
{ {
// Write size of LPtrList // Write size
os << nl << slpl.size(); os << nl << lst.size();
// Write beginning of contents // Write beginning of contents
os << nl << token::BEGIN_LIST << nl; os << nl << token::BEGIN_LIST << nl;
// Write LPtrList contents // Write contents
for for
( (
typename LPtrList<LListBase, T>::const_iterator iter = slpl.begin(); typename LPtrList<LListBase, T>::const_iterator iter = lst.begin();
iter != slpl.end(); iter != lst.end();
++iter ++iter
) )
{ {
@ -200,14 +194,9 @@ Ostream& operator<<(Ostream& os, const LPtrList<LListBase, T>& slpl)
os << token::END_LIST; os << token::END_LIST;
// Check state of IOstream // Check state of IOstream
os.check("Ostream& operator<<(Ostream&, const LPtrList&)"); os.check("Ostream& operator<<(Ostream&, const LPtrList<LListBase, T>&)");
return os; return os;
} }
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// ************************************************************************* // // ************************************************************************* //

34
src/OpenFOAM/containers/LinkedLists/accessTypes/UILList/UILList.C
View file

@ -28,17 +28,12 @@ Description
#include "UILList.H" #include "UILList.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
template<class LListBase, class T> template<class LListBase, class T>
UILList<LListBase, T>::UILList(const UILList<LListBase, T>& slpl) Foam::UILList<LListBase, T>::UILList(const UILList<LListBase, T>& lst)
{ {
for (const_iterator iter = slpl.begin(); iter != slpl.end(); ++iter) for (const_iterator iter = lst.begin(); iter != lst.end(); ++iter)
{ {
append(&iter()); append(&iter());
} }
@ -48,22 +43,24 @@ UILList<LListBase, T>::UILList(const UILList<LListBase, T>& slpl)
// * * * * * * * * * * * * * * * Member Operators * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * Member Operators * * * * * * * * * * * * * //
template<class LListBase, class T> template<class LListBase, class T>
void UILList<LListBase, T>::operator=(const UILList<LListBase, T>& slpl) void Foam::UILList<LListBase, T>::operator=(const UILList<LListBase, T>& rhs)
{ {
LListBase::clear(); LListBase::clear();
for (const_iterator iter = slpl.begin(); iter != slpl.end(); ++iter) for (const_iterator iter = rhs.begin(); iter != rhs.end(); ++iter)
{ {
append(&iter()); append(&iter());
} }
} }
// Comparison for equality
template<class LListBase, class T> template<class LListBase, class T>
bool UILList<LListBase, T>::operator==(const UILList<LListBase, T>& slpl) const bool Foam::UILList<LListBase, T>::operator==
(
const UILList<LListBase, T>& rhs
) const
{ {
if (this->size() != slpl.size()) if (this->size() != rhs.size())
{ {
return false; return false;
} }
@ -71,7 +68,7 @@ bool UILList<LListBase, T>::operator==(const UILList<LListBase, T>& slpl) const
bool equal = true; bool equal = true;
const_iterator iter1 = this->begin(); const_iterator iter1 = this->begin();
const_iterator iter2 = slpl.begin(); const_iterator iter2 = rhs.begin();
for (; iter1 != this->end(); ++iter1, ++iter2) for (; iter1 != this->end(); ++iter1, ++iter2)
{ {
@ -84,16 +81,15 @@ bool UILList<LListBase, T>::operator==(const UILList<LListBase, T>& slpl) const
// Comparison for inequality // Comparison for inequality
template<class LListBase, class T> template<class LListBase, class T>
bool UILList<LListBase, T>::operator!=(const UILList<LListBase, T>& slpl) const bool Foam::UILList<LListBase, T>::operator!=
(
const UILList<LListBase, T>& rhs
) const
{ {
return !operator==(slpl); return !operator==(rhs);
} }
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// * * * * * * * * * * * * * * * Friend Operators * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * Friend Operators * * * * * * * * * * * * * //
#include "UILListIO.C" #include "UILListIO.C"

8
src/OpenFOAM/containers/LinkedLists/accessTypes/UILList/UILList.H
View file

@ -38,6 +38,7 @@ SourceFiles
#define UILList_H #define UILList_H
#include "label.H" #include "label.H"
#include "uLabel.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
@ -266,7 +267,7 @@ public:
// STL member operators // STL member operators
//- Equality operation on ULists of the same type. //- Equality operation on ULists of the same type.
// Returns true when the ULists are elementwise equal // Returns true when the ULists are element-wise equal
// (using UList::value_type::operator==). Takes linear time. // (using UList::value_type::operator==). Takes linear time.
bool operator==(const UILList<LListBase, T>&) const; bool operator==(const UILList<LListBase, T>&) const;
@ -276,10 +277,7 @@ public:
// Ostream operator // Ostream operator
friend Ostream& operator<< friend Ostream& operator<< <LListBase, T>
#ifndef __CINT__
<LListBase, T>
#endif
( (
Ostream&, Ostream&,
const UILList<LListBase, T>& const UILList<LListBase, T>&

24
src/OpenFOAM/containers/LinkedLists/accessTypes/UILList/UILListIO.C
View file

@ -30,27 +30,22 @@ Description
#include "Ostream.H" #include "Ostream.H"
#include "token.H" #include "token.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
// * * * * * * * * * * * * * * * Ostream Operator * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * Ostream Operator * * * * * * * * * * * * * //
template<class LListBase, class T> template<class LListBase, class T>
Ostream& operator<<(Ostream& os, const UILList<LListBase, T>& ill) Foam::Ostream& Foam::operator<<(Ostream& os, const UILList<LListBase, T>& lst)
{ {
// Write size of UILList // Write size
os << nl << ill.size(); os << nl << lst.size();
// Write beginning of contents // Write beginning of contents
os << nl << token::BEGIN_LIST << nl; os << nl << token::BEGIN_LIST << nl;
// Write UILList contents // Write contents
for for
( (
typename UILList<LListBase, T>::const_iterator iter = ill.begin(); typename UILList<LListBase, T>::const_iterator iter = lst.begin();
iter != ill.end(); iter != lst.end();
++iter ++iter
) )
{ {
@ -61,14 +56,9 @@ Ostream& operator<<(Ostream& os, const UILList<LListBase, T>& ill)
os << token::END_LIST; os << token::END_LIST;
// Check state of IOstream // Check state of IOstream
os.check("Ostream& operator<<(Ostream&, const UILList&)"); os.check("Ostream& operator<<(Ostream&, const UILList<LListBase, T>&)");
return os; return os;
} }
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// ************************************************************************* // // ************************************************************************* //

31
src/OpenFOAM/containers/LinkedLists/linkTypes/DLListBase/DLListBase.C
View file

@ -30,28 +30,23 @@ License
#include "IOstreams.H" #include "IOstreams.H"
#include "long.H" #include "long.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
namespace Foam Foam::DLListBase::iterator Foam::DLListBase::endIter_
{
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
DLListBase::iterator DLListBase::endIter
( (
const_cast<DLListBase&>(static_cast<const DLListBase&>(DLListBase())) const_cast<DLListBase&>(static_cast<const DLListBase&>(DLListBase()))
); );
DLListBase::const_iterator DLListBase::endConstIter Foam::DLListBase::const_iterator Foam::DLListBase::endConstIter_
( (
static_cast<const DLListBase&>(DLListBase()), static_cast<const DLListBase&>(DLListBase()),
reinterpret_cast<const link*>(NULL) reinterpret_cast<const link*>(0)
); );
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
void DLListBase::insert(DLListBase::link* a) void Foam::DLListBase::insert(DLListBase::link* a)
{ {
nElmts_++; nElmts_++;
@ -71,7 +66,7 @@ void DLListBase::insert(DLListBase::link* a)
} }
void DLListBase::append(DLListBase::link* a) void Foam::DLListBase::append(DLListBase::link* a)
{ {
nElmts_++; nElmts_++;
@ -91,7 +86,7 @@ void DLListBase::append(DLListBase::link* a)
} }
bool DLListBase::swapUp(DLListBase::link* a) bool Foam::DLListBase::swapUp(DLListBase::link* a)
{ {
if (first_ != a) if (first_ != a)
{ {
@ -132,7 +127,7 @@ bool DLListBase::swapUp(DLListBase::link* a)
} }
bool DLListBase::swapDown(DLListBase::link* a) bool Foam::DLListBase::swapDown(DLListBase::link* a)
{ {
if (last_ != a) if (last_ != a)
{ {
@ -173,7 +168,7 @@ bool DLListBase::swapDown(DLListBase::link* a)
} }
DLListBase::link* DLListBase::removeHead() Foam::DLListBase::link* Foam::DLListBase::removeHead()
{ {
nElmts_--; nElmts_--;
@ -197,7 +192,7 @@ DLListBase::link* DLListBase::removeHead()
} }
DLListBase::link* DLListBase::remove(DLListBase::link* l) Foam::DLListBase::link* Foam::DLListBase::remove(DLListBase::link* l)
{ {
nElmts_--; nElmts_--;
@ -229,7 +224,7 @@ DLListBase::link* DLListBase::remove(DLListBase::link* l)
} }
DLListBase::link* DLListBase::replace Foam::DLListBase::link* Foam::DLListBase::replace
( (
DLListBase::link* oldLink, DLListBase::link* oldLink,
DLListBase::link* newLink DLListBase::link* newLink
@ -266,8 +261,4 @@ DLListBase::link* DLListBase::replace
} }
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// ************************************************************************* // // ************************************************************************* //

38
src/OpenFOAM/containers/LinkedLists/linkTypes/DLListBase/DLListBase.H
View file

@ -38,6 +38,7 @@ SourceFiles
#include "bool.H" #include "bool.H"
#include "label.H" #include "label.H"
#include "uLabel.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
@ -122,6 +123,9 @@ public:
//- Return number of elements in list //- Return number of elements in list
inline label size() const; inline label size() const;
//- Return true if the list is empty
inline bool empty() const;
//- Return first entry //- Return first entry
inline link* first(); inline link* first();
@ -167,10 +171,13 @@ public:
//- Clear the list //- Clear the list
inline void clear(); inline void clear();
//- Transfer the contents of the argument into this List
// and annull the argument list.
inline void transfer(DLListBase&);
// STL iterator // STL iterator
//- An STL iterator //- An STL-conforming iterator
class iterator class iterator
{ {
friend class DLListBase; friend class DLListBase;
@ -187,16 +194,17 @@ public:
//- Copy of the link //- Copy of the link
link curLink_; link curLink_;
// Private Member Functions
//- Construct for a given SLListBase with NULL element and link.
// Only used to create endIter
inline iterator(DLListBase&);
public: public:
//- Construct for a given DLListBase and link //- Construct for a given DLListBase and link
inline iterator(DLListBase&, link*); inline iterator(DLListBase&, link*);
//- Construct for a given DLListBase
// setting element and link to NULL.
// Only used to create endIter
inline iterator(DLListBase&);
// Member operators // Member operators
inline void operator=(const iterator&); inline void operator=(const iterator&);
@ -211,16 +219,12 @@ public:
}; };
inline iterator begin(); inline iterator begin();
//- iterator returned by end()
static iterator endIter;
inline const iterator& end(); inline const iterator& end();
// STL const_iterator // STL const_iterator
//- An STL const_iterator //- An STL-conforming const_iterator
class const_iterator class const_iterator
{ {
// Private data // Private data
@ -252,12 +256,20 @@ public:
inline const_iterator operator++(int); inline const_iterator operator++(int);
}; };
inline const_iterator cbegin() const;
inline const const_iterator& cend() const;
inline const_iterator begin() const; inline const_iterator begin() const;
inline const const_iterator& end() const;
private:
//- iterator returned by end()
static iterator endIter_;
//- const_iterator returned by end() //- const_iterator returned by end()
static const_iterator endConstIter; static const_iterator endConstIter_;
inline const const_iterator& end() const;
}; };

136
src/OpenFOAM/containers/LinkedLists/linkTypes/DLListBase/DLListBaseI.H
View file

@ -26,21 +26,16 @@ License
#include "error.H" #include "error.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
// * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * * //
inline DLListBase::link::link() inline Foam::DLListBase::link::link()
: :
prev_(0), prev_(0),
next_(0) next_(0)
{} {}
inline DLListBase::DLListBase() inline Foam::DLListBase::DLListBase()
: :
first_(0), first_(0),
last_(0), last_(0),
@ -48,7 +43,7 @@ inline DLListBase::DLListBase()
{} {}
inline DLListBase::DLListBase(link* a) inline Foam::DLListBase::DLListBase(link* a)
: :
first_(a), first_(a),
last_(a), last_(a),
@ -61,32 +56,39 @@ inline DLListBase::DLListBase(link* a)
// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * //
inline DLListBase::~DLListBase() inline Foam::DLListBase::~DLListBase()
{} {}
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
inline bool DLListBase::link::registered() const inline bool Foam::DLListBase::link::registered() const
{ {
return prev_ != 0 && next_ != 0; return prev_ != 0 && next_ != 0;
} }
inline void DLListBase::link::deregister() inline void Foam::DLListBase::link::deregister()
{ {
prev_ = 0; prev_ = 0;
next_ = 0; next_ = 0;
} }
inline label DLListBase::size() const inline Foam::label Foam::DLListBase::size() const
{ {
return nElmts_; return nElmts_;
} }
inline DLListBase::link* DLListBase::first() inline bool Foam::DLListBase::empty() const
{
return !nElmts_;
}
inline Foam::DLListBase::link*
Foam::DLListBase::first()
{ {
if (!nElmts_) if (!nElmts_)
{ {
@ -98,7 +100,8 @@ inline DLListBase::link* DLListBase::first()
} }
inline const DLListBase::link* DLListBase::first() const inline const Foam::DLListBase::link*
Foam::DLListBase::first() const
{ {
if (!nElmts_) if (!nElmts_)
{ {
@ -110,7 +113,8 @@ inline const DLListBase::link* DLListBase::first() const
} }
inline DLListBase::link* DLListBase::last() inline Foam::DLListBase::link*
Foam::DLListBase::last()
{ {
if (!nElmts_) if (!nElmts_)
{ {
@ -122,7 +126,8 @@ inline DLListBase::link* DLListBase::last()
} }
inline const DLListBase::link* DLListBase::last() const inline const Foam::DLListBase::link*
Foam::DLListBase::last() const
{ {
if (!nElmts_) if (!nElmts_)
{ {
@ -134,21 +139,36 @@ inline const DLListBase::link* DLListBase::last() const
} }
inline void DLListBase::clear() inline void Foam::DLListBase::clear()
{ {
nElmts_ = 0;
first_ = 0; first_ = 0;
last_ = 0; last_ = 0;
nElmts_ = 0;
} }
inline DLListBase::link* DLListBase::remove(DLListBase::iterator& it) inline void Foam::DLListBase::transfer(DLListBase& lst)
{
first_ = lst.first_;
last_ = lst.last_;
nElmts_ = lst.nElmts_;
lst.clear();
}
inline Foam::DLListBase::link*
Foam::DLListBase::remove
(
DLListBase::iterator& it
)
{ {
return remove(it.curElmt_); return remove(it.curElmt_);
} }
inline DLListBase::link* DLListBase::replace inline Foam::DLListBase::link*
Foam::DLListBase::replace
( (
DLListBase::iterator& oldIter, DLListBase::iterator& oldIter,
DLListBase::link* newLink DLListBase::link* newLink
@ -160,7 +180,7 @@ inline DLListBase::link* DLListBase::replace
// * * * * * * * * * * * * * * * STL iterator * * * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * STL iterator * * * * * * * * * * * * * * * //
inline DLListBase::iterator::iterator(DLListBase& s, link* elmt) inline Foam::DLListBase::iterator::iterator(DLListBase& s, link* elmt)
: :
curList_(s), curList_(s),
curElmt_(elmt), curElmt_(elmt),
@ -168,7 +188,7 @@ inline DLListBase::iterator::iterator(DLListBase& s, link* elmt)
{} {}
inline DLListBase::iterator::iterator(DLListBase& s) inline Foam::DLListBase::iterator::iterator(DLListBase& s)
: :
curList_(s), curList_(s),
curElmt_(NULL), curElmt_(NULL),
@ -176,32 +196,34 @@ inline DLListBase::iterator::iterator(DLListBase& s)
{} {}
inline void DLListBase::iterator::operator=(const iterator& iter) inline void Foam::DLListBase::iterator::operator=(const iterator& iter)
{ {
curElmt_ = iter.curElmt_; curElmt_ = iter.curElmt_;
curLink_ = iter.curLink_; curLink_ = iter.curLink_;
} }
inline bool DLListBase::iterator::operator==(const iterator& iter) const inline bool Foam::DLListBase::iterator::operator==(const iterator& iter) const
{ {
return curElmt_ == iter.curElmt_; return curElmt_ == iter.curElmt_;
} }
inline bool DLListBase::iterator::operator!=(const iterator& iter) const inline bool Foam::DLListBase::iterator::operator!=(const iterator& iter) const
{ {
return curElmt_ != iter.curElmt_; return curElmt_ != iter.curElmt_;
} }
inline DLListBase::link& DLListBase::iterator::operator*() inline Foam::DLListBase::link&
Foam::DLListBase::iterator::operator*()
{ {
return *curElmt_; return *curElmt_;
} }
inline DLListBase::iterator& DLListBase::iterator::operator++() inline Foam::DLListBase::iterator&
Foam::DLListBase::iterator::operator++()
{ {
// Check if the curElmt_ is the last element (if it points to itself) // Check if the curElmt_ is the last element (if it points to itself)
// or if the list is empty because the last element may have been removed // or if the list is empty because the last element may have been removed
@ -219,7 +241,8 @@ inline DLListBase::iterator& DLListBase::iterator::operator++()
} }
inline DLListBase::iterator DLListBase::iterator::operator++(int) inline Foam::DLListBase::iterator
Foam::DLListBase::iterator::operator++(int)
{ {
iterator tmp = *this; iterator tmp = *this;
++*this; ++*this;
@ -227,7 +250,8 @@ inline DLListBase::iterator DLListBase::iterator::operator++(int)
} }
inline DLListBase::iterator DLListBase::begin() inline Foam::DLListBase::iterator
Foam::DLListBase::begin()
{ {
if (size()) if (size())
{ {
@ -235,20 +259,20 @@ inline DLListBase::iterator DLListBase::begin()
} }
else else
{ {
return endIter; return endIter_;
} }
} }
inline const DLListBase::iterator& DLListBase::end() inline const Foam::DLListBase::iterator& Foam::DLListBase::end()
{ {
return endIter; return endIter_;
} }
// * * * * * * * * * * * * * * STL const_iterator * * * * * * * * * * * * * // // * * * * * * * * * * * * * * STL const_iterator * * * * * * * * * * * * * //
inline DLListBase::const_iterator::const_iterator inline Foam::DLListBase::const_iterator::const_iterator
( (
const DLListBase& s, const DLListBase& s,
const link* elmt const link* elmt
@ -259,20 +283,23 @@ inline DLListBase::const_iterator::const_iterator
{} {}
inline DLListBase::const_iterator::const_iterator(const iterator& iter) inline Foam::DLListBase::const_iterator::const_iterator(const iterator& iter)
: :
curList_(iter.curList_), curList_(iter.curList_),
curElmt_(iter.curElmt_) curElmt_(iter.curElmt_)
{} {}
inline void DLListBase::const_iterator::operator=(const const_iterator& iter) inline void Foam::DLListBase::const_iterator::operator=
(
const const_iterator& iter
)
{ {
curElmt_ = iter.curElmt_; curElmt_ = iter.curElmt_;
} }
inline bool DLListBase::const_iterator::operator== inline bool Foam::DLListBase::const_iterator::operator==
( (
const const_iterator& iter const const_iterator& iter
) const ) const
@ -281,7 +308,7 @@ inline bool DLListBase::const_iterator::operator==
} }
inline bool DLListBase::const_iterator::operator!= inline bool Foam::DLListBase::const_iterator::operator!=
( (
const const_iterator& iter const const_iterator& iter
) const ) const
@ -290,13 +317,15 @@ inline bool DLListBase::const_iterator::operator!=
} }
inline const DLListBase::link& DLListBase::const_iterator::operator*() inline const Foam::DLListBase::link&
Foam::DLListBase::const_iterator::operator*()
{ {
return *curElmt_; return *curElmt_;
} }
inline DLListBase::const_iterator& DLListBase::const_iterator::operator++() inline Foam::DLListBase::const_iterator&
Foam::DLListBase::const_iterator::operator++()
{ {
if (curElmt_ == curList_.last_) if (curElmt_ == curList_.last_)
{ {
@ -311,7 +340,8 @@ inline DLListBase::const_iterator& DLListBase::const_iterator::operator++()
} }
inline DLListBase::const_iterator DLListBase::const_iterator::operator++(int) inline Foam::DLListBase::const_iterator
Foam::DLListBase::const_iterator::operator++(int)
{ {
const_iterator tmp = *this; const_iterator tmp = *this;
++*this; ++*this;
@ -319,7 +349,8 @@ inline DLListBase::const_iterator DLListBase::const_iterator::operator++(int)
} }
inline DLListBase::const_iterator DLListBase::begin() const inline Foam::DLListBase::const_iterator
Foam::DLListBase::cbegin() const
{ {
if (size()) if (size())
{ {
@ -327,19 +358,30 @@ inline DLListBase::const_iterator DLListBase::begin() const
} }
else else
{ {
return endConstIter; return endConstIter_;
} }
} }
inline const DLListBase::const_iterator& DLListBase::end() const inline const Foam::DLListBase::const_iterator&
Foam::DLListBase::cend() const
{ {
return endConstIter; return endConstIter_;
} }
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // inline Foam::DLListBase::const_iterator
Foam::DLListBase::begin() const
{
return this->cbegin();
}
inline const Foam::DLListBase::const_iterator&
Foam::DLListBase::end() const
{
return endConstIter_;
}
} // End namespace Foam
// ************************************************************************* // // ************************************************************************* //

24
src/OpenFOAM/containers/LinkedLists/linkTypes/SLListBase/SLListBase.C
View file

@ -25,31 +25,25 @@ License
\*---------------------------------------------------------------------------*/ \*---------------------------------------------------------------------------*/
#include "error.H" #include "error.H"
#include "SLListBase.H" #include "SLListBase.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam Foam::SLListBase::iterator Foam::SLListBase::endIter_
{
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
SLListBase::iterator SLListBase::endIter
( (
const_cast<SLListBase&>(static_cast<const SLListBase&>(SLListBase())) const_cast<SLListBase&>(static_cast<const SLListBase&>(SLListBase()))
); );
SLListBase::const_iterator SLListBase::endConstIter Foam::SLListBase::const_iterator Foam::SLListBase::endConstIter_
( (
static_cast<const SLListBase&>(SLListBase()), static_cast<const SLListBase&>(SLListBase()),
reinterpret_cast<const link*>(NULL) reinterpret_cast<const link*>(0)
); );
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
void SLListBase::insert(SLListBase::link* a) void Foam::SLListBase::insert(SLListBase::link* a)
{ {
nElmts_++; nElmts_++;
@ -66,7 +60,7 @@ void SLListBase::insert(SLListBase::link* a)
} }
void SLListBase::append(SLListBase::link* a) void Foam::SLListBase::append(SLListBase::link* a)
{ {
nElmts_++; nElmts_++;
@ -82,7 +76,7 @@ void SLListBase::append(SLListBase::link* a)
} }
SLListBase::link* SLListBase::removeHead() Foam::SLListBase::link* Foam::SLListBase::removeHead()
{ {
nElmts_--; nElmts_--;
@ -108,7 +102,7 @@ SLListBase::link* SLListBase::removeHead()
} }
SLListBase::link* SLListBase::remove(SLListBase::link* it) Foam::SLListBase::link* Foam::SLListBase::remove(SLListBase::link* it)
{ {
SLListBase::iterator iter = begin(); SLListBase::iterator iter = begin();
SLListBase::link *prev = &(*iter); SLListBase::link *prev = &(*iter);
@ -143,8 +137,4 @@ SLListBase::link* SLListBase::remove(SLListBase::link* it)
} }
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// ************************************************************************* // // ************************************************************************* //

37
src/OpenFOAM/containers/LinkedLists/linkTypes/SLListBase/SLListBase.H
View file

@ -38,6 +38,7 @@ SourceFiles
#include "bool.H" #include "bool.H"
#include "label.H" #include "label.H"
#include "uLabel.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
@ -119,6 +120,9 @@ public:
//- Return number of elements in list //- Return number of elements in list
inline label size() const; inline label size() const;
//- Return true if the list is empty
inline bool empty() const;
//- Return first entry //- Return first entry
inline link* first(); inline link* first();
@ -152,6 +156,9 @@ public:
//- Clear the list //- Clear the list
inline void clear(); inline void clear();
//- Transfer the contents of the argument into this List
// and annull the argument list.
inline void transfer(SLListBase&);
// STL iterator // STL iterator
@ -172,17 +179,17 @@ public:
//- Copy of the link //- Copy of the link
link curLink_; link curLink_;
// Private Member Functions
//- Construct for a given SLListBase with NULL element and link.
// Only used to create endIter
inline iterator(SLListBase&);
public: public:
//- Construct for a given SLListBase and link //- Construct for a given SLListBase and link
inline iterator(SLListBase&, link*); inline iterator(SLListBase&, link*);
//- Construct for a given SLListBase
// setting element and link to NULL.
// Only used to create endIter
inline iterator(SLListBase&);
// Member operators // Member operators
inline void operator=(const iterator&); inline void operator=(const iterator&);
@ -197,10 +204,6 @@ public:
}; };
inline iterator begin(); inline iterator begin();
//- iterator returned by end()
static iterator endIter;
inline const iterator& end(); inline const iterator& end();
@ -239,12 +242,20 @@ public:
inline const_iterator operator++(int); inline const_iterator operator++(int);
}; };
inline const_iterator cbegin() const;
inline const const_iterator& cend() const;
inline const_iterator begin() const; inline const_iterator begin() const;
inline const const_iterator& end() const;
private:
//- iterator returned by end()
static iterator endIter_;
//- const_iterator returned by end() //- const_iterator returned by end()
static const_iterator endConstIter; static const_iterator endConstIter_;
inline const const_iterator& end() const;
}; };

126
src/OpenFOAM/containers/LinkedLists/linkTypes/SLListBase/SLListBaseI.H
View file

@ -29,33 +29,28 @@ Description
#include "error.H" #include "error.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
// * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * * //
inline SLListBase::link::link() inline Foam::SLListBase::link::link()
: :
next_(0) next_(0)
{} {}
inline SLListBase::link::link(link* p) inline Foam::SLListBase::link::link(link* p)
: :
next_(p) next_(p)
{} {}
inline SLListBase::SLListBase() inline Foam::SLListBase::SLListBase()
: :
last_(0), last_(0),
nElmts_(0) nElmts_(0)
{} {}
inline SLListBase::SLListBase(link* a) inline Foam::SLListBase::SLListBase(link* a)
: :
last_(a->next_ = a), last_(a->next_ = a),
nElmts_(1) nElmts_(1)
@ -64,19 +59,26 @@ inline SLListBase::SLListBase(link* a)
// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * //
inline SLListBase::~SLListBase() inline Foam::SLListBase::~SLListBase()
{} {}
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
inline label SLListBase::size() const inline Foam::label Foam::SLListBase::size() const
{ {
return nElmts_; return nElmts_;
} }
inline SLListBase::link* SLListBase::first() inline bool Foam::SLListBase::empty() const
{
return !nElmts_;
}
inline Foam::SLListBase::link*
Foam::SLListBase::first()
{ {
if (!nElmts_) if (!nElmts_)
{ {
@ -88,7 +90,8 @@ inline SLListBase::link* SLListBase::first()
} }
inline const SLListBase::link* SLListBase::first() const inline const Foam::SLListBase::link*
Foam::SLListBase::first() const
{ {
if (!nElmts_) if (!nElmts_)
{ {
@ -100,7 +103,8 @@ inline const SLListBase::link* SLListBase::first() const
} }
inline SLListBase::link* SLListBase::last() inline Foam::SLListBase::link*
Foam::SLListBase::last()
{ {
if (!nElmts_) if (!nElmts_)
{ {
@ -112,7 +116,8 @@ inline SLListBase::link* SLListBase::last()
} }
inline const SLListBase::link* SLListBase::last() const inline const Foam::SLListBase::link*
Foam::SLListBase::last() const
{ {
if (!nElmts_) if (!nElmts_)
{ {
@ -124,14 +129,26 @@ inline const SLListBase::link* SLListBase::last() const
} }
inline void SLListBase::clear() inline void Foam::SLListBase::clear()
{ {
nElmts_ = 0;
last_ = 0; last_ = 0;
nElmts_ = 0;
} }
inline SLListBase::link* SLListBase::remove(SLListBase::iterator& it) inline void Foam::SLListBase::transfer(SLListBase& lst)
{
last_ = lst.last_;
nElmts_ = lst.nElmts_;
lst.clear();
}
inline Foam::SLListBase::link* Foam::SLListBase::remove
(
SLListBase::iterator& it
)
{ {
return remove(it.curElmt_); return remove(it.curElmt_);
} }
@ -139,7 +156,7 @@ inline SLListBase::link* SLListBase::remove(SLListBase::iterator& it)
// * * * * * * * * * * * * * * * STL iterator * * * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * STL iterator * * * * * * * * * * * * * * * //
inline SLListBase::iterator::iterator(SLListBase& s, link* elmt) inline Foam::SLListBase::iterator::iterator(SLListBase& s, link* elmt)
: :
curList_(s), curList_(s),
curElmt_(elmt), curElmt_(elmt),
@ -147,7 +164,7 @@ inline SLListBase::iterator::iterator(SLListBase& s, link* elmt)
{} {}
inline SLListBase::iterator::iterator(SLListBase& s) inline Foam::SLListBase::iterator::iterator(SLListBase& s)
: :
curList_(s), curList_(s),
curElmt_(NULL), curElmt_(NULL),
@ -155,32 +172,32 @@ inline SLListBase::iterator::iterator(SLListBase& s)
{} {}
inline void SLListBase::iterator::operator=(const iterator& iter) inline void Foam::SLListBase::iterator::operator=(const iterator& iter)
{ {
curElmt_ = iter.curElmt_; curElmt_ = iter.curElmt_;
curLink_ = iter.curLink_; curLink_ = iter.curLink_;
} }
inline bool SLListBase::iterator::operator==(const iterator& iter) const inline bool Foam::SLListBase::iterator::operator==(const iterator& iter) const
{ {
return curElmt_ == iter.curElmt_; return curElmt_ == iter.curElmt_;
} }
inline bool SLListBase::iterator::operator!=(const iterator& iter) const inline bool Foam::SLListBase::iterator::operator!=(const iterator& iter) const
{ {
return curElmt_ != iter.curElmt_; return curElmt_ != iter.curElmt_;
} }
inline SLListBase::link& SLListBase::iterator::operator*() inline Foam::SLListBase::link& Foam::SLListBase::iterator::operator*()
{ {
return *curElmt_; return *curElmt_;
} }
inline SLListBase::iterator& SLListBase::iterator::operator++() inline Foam::SLListBase::iterator& Foam::SLListBase::iterator::operator++()
{ {
if (curElmt_ == curList_.last_ || curList_.last_ == 0) if (curElmt_ == curList_.last_ || curList_.last_ == 0)
{ {
@ -196,7 +213,8 @@ inline SLListBase::iterator& SLListBase::iterator::operator++()
} }
inline SLListBase::iterator SLListBase::iterator::operator++(int) inline Foam::SLListBase::iterator
Foam::SLListBase::iterator::operator++(int)
{ {
iterator tmp = *this; iterator tmp = *this;
++*this; ++*this;
@ -204,7 +222,8 @@ inline SLListBase::iterator SLListBase::iterator::operator++(int)
} }
inline SLListBase::iterator SLListBase::begin() inline Foam::SLListBase::iterator
Foam::SLListBase::begin()
{ {
if (size()) if (size())
{ {
@ -212,20 +231,21 @@ inline SLListBase::iterator SLListBase::begin()
} }
else else
{ {
return endIter; return endIter_;
} }
} }
inline const SLListBase::iterator& SLListBase::end() inline const Foam::SLListBase::iterator&
Foam::SLListBase::end()
{ {
return endIter; return endIter_;
} }
// * * * * * * * * * * * * * * STL const_iterator * * * * * * * * * * * * * // // * * * * * * * * * * * * * * STL const_iterator * * * * * * * * * * * * * //
inline SLListBase::const_iterator::const_iterator inline Foam::SLListBase::const_iterator::const_iterator
( (
const SLListBase& s, const SLListBase& s,
const link* elmt const link* elmt
@ -236,20 +256,23 @@ inline SLListBase::const_iterator::const_iterator
{} {}
inline SLListBase::const_iterator::const_iterator(const iterator& iter) inline Foam::SLListBase::const_iterator::const_iterator(const iterator& iter)
: :
curList_(iter.curList_), curList_(iter.curList_),
curElmt_(iter.curElmt_) curElmt_(iter.curElmt_)
{} {}
inline void SLListBase::const_iterator::operator=(const const_iterator& iter) inline void Foam::SLListBase::const_iterator::operator=
(
const const_iterator& iter
)
{ {
curElmt_ = iter.curElmt_; curElmt_ = iter.curElmt_;
} }
inline bool SLListBase::const_iterator::operator== inline bool Foam::SLListBase::const_iterator::operator==
( (
const const_iterator& iter const const_iterator& iter
) const ) const
@ -258,7 +281,7 @@ inline bool SLListBase::const_iterator::operator==
} }
inline bool SLListBase::const_iterator::operator!= inline bool Foam::SLListBase::const_iterator::operator!=
( (
const const_iterator& iter const const_iterator& iter
) const ) const
@ -267,13 +290,15 @@ inline bool SLListBase::const_iterator::operator!=
} }
inline const SLListBase::link& SLListBase::const_iterator::operator*() inline const Foam::SLListBase::link&
Foam::SLListBase::const_iterator::operator*()
{ {
return *curElmt_; return *curElmt_;
} }
inline SLListBase::const_iterator& SLListBase::const_iterator::operator++() inline Foam::SLListBase::const_iterator&
Foam::SLListBase::const_iterator::operator++()
{ {
if (curElmt_ == curList_.last_) if (curElmt_ == curList_.last_)
{ {
@ -288,7 +313,8 @@ inline SLListBase::const_iterator& SLListBase::const_iterator::operator++()
} }
inline SLListBase::const_iterator SLListBase::const_iterator::operator++(int) inline Foam::SLListBase::const_iterator
Foam::SLListBase::const_iterator::operator++(int)
{ {
const_iterator tmp = *this; const_iterator tmp = *this;
++*this; ++*this;
@ -296,7 +322,8 @@ inline SLListBase::const_iterator SLListBase::const_iterator::operator++(int)
} }
inline SLListBase::const_iterator SLListBase::begin() const inline Foam::SLListBase::const_iterator
Foam::SLListBase::cbegin() const
{ {
if (size()) if (size())
{ {
@ -304,19 +331,30 @@ inline SLListBase::const_iterator SLListBase::begin() const
} }
else else
{ {
return endConstIter; return endConstIter_;
} }
} }
inline const SLListBase::const_iterator& SLListBase::end() const inline const Foam::SLListBase::const_iterator&
Foam::SLListBase::cend() const
{ {
return endConstIter; return endConstIter_;
} }
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // inline Foam::SLListBase::const_iterator
Foam::SLListBase::begin() const
{
return this->cbegin();
}
inline const Foam::SLListBase::const_iterator&
Foam::SLListBase::end() const
{
return endConstIter_;
}
} // End namespace Foam
// ************************************************************************* // // ************************************************************************* //

0
src/OpenFOAM/containers/LinkedLists/user/DLList/DLList.H → src/OpenFOAM/containers/LinkedLists/user/DLList.H
View file

0
src/OpenFOAM/containers/LinkedLists/user/DLPtrList/DLPtrList.H → src/OpenFOAM/containers/LinkedLists/user/DLPtrList.H
View file

9
src/OpenFOAM/containers/LinkedLists/user/FIFOStack/FIFOStack.H → src/OpenFOAM/containers/LinkedLists/user/FIFOStack.H
View file

@ -92,15 +92,6 @@ public:
} }
// Check
//- Is the stack empty
bool empty() const
{
return this->size() == 0;
}
// Edit // Edit
//- Push an element onto the stack //- Push an element onto the stack

0
src/OpenFOAM/containers/LinkedLists/user/IDLList/IDLList.H → src/OpenFOAM/containers/LinkedLists/user/IDLList.H
View file

0
src/OpenFOAM/containers/LinkedLists/user/ISLList/ISLList.H → src/OpenFOAM/containers/LinkedLists/user/ISLList.H
View file

9
src/OpenFOAM/containers/LinkedLists/user/LIFOStack/LIFOStack.H → src/OpenFOAM/containers/LinkedLists/user/LIFOStack.H
View file

@ -92,15 +92,6 @@ public:
} }
// Check
//- Is the stack empty
bool empty() const
{
return this->size() == 0;
}
// Edit // Edit
//- Push an element onto the stack //- Push an element onto the stack

0
src/OpenFOAM/containers/LinkedLists/user/SLList/SLList.H → src/OpenFOAM/containers/LinkedLists/user/SLList.H
View file

0
src/OpenFOAM/containers/LinkedLists/user/SLPtrList/SLPtrList.H → src/OpenFOAM/containers/LinkedLists/user/SLPtrList.H
View file

0
src/OpenFOAM/containers/LinkedLists/user/UIDLList/UIDLList.H → src/OpenFOAM/containers/LinkedLists/user/UIDLList.H
View file

11
src/OpenFOAM/containers/Lists/BiIndirectList/BiIndirectList.H
View file

@ -26,8 +26,7 @@ Class
Foam::BiIndirectList Foam::BiIndirectList
Description Description
Indexes into left list (negative index) or right list (zero or positive Indexes into negList (negative index) or posList (zero or positive index).
index).
SourceFiles SourceFiles
BiIndirectListI.H BiIndirectListI.H
@ -67,7 +66,7 @@ public:
( (
const UList<T>& posList, const UList<T>& posList,
const UList<T>& negList, const UList<T>& negList,
const List<label>& const UList<label>&
); );
@ -76,14 +75,16 @@ public:
// Access // Access
inline label size() const; inline label size() const;
inline bool empty() const;
inline const UList<T>& posList() const; inline const UList<T>& posList() const;
inline const UList<T>& negList() const; inline const UList<T>& negList() const;
inline const List<label>& addressing() const; inline const List<label>& addressing() const;
inline List<label>& addressing(); inline List<label>& addressing();
//- Calculate index given whether index is into posList or negList //- Calculate index given whether index is into posList or negList
inline static label posIndex(const label i); inline static label posIndex(const label);
inline static label negIndex(const label i); inline static label negIndex(const label);
// Member Operators // Member Operators

9
src/OpenFOAM/containers/Lists/BiIndirectList/BiIndirectListI.H
View file

@ -31,7 +31,7 @@ inline Foam::BiIndirectList<T>::BiIndirectList
( (
const UList<T>& posList, const UList<T>& posList,
const UList<T>& negList, const UList<T>& negList,
const List<label>& addr const UList<label>& addr
) )
: :
posList_(const_cast<UList<T>&>(posList)), posList_(const_cast<UList<T>&>(posList)),
@ -49,6 +49,13 @@ inline Foam::label Foam::BiIndirectList<T>::size() const
} }
template<class T>
inline bool Foam::BiIndirectList<T>::empty() const
{
return addressing_.empty();
}
template<class T> template<class T>
inline const Foam::UList<T>& Foam::BiIndirectList<T>::posList() const inline const Foam::UList<T>& Foam::BiIndirectList<T>::posList() const
{ {

111
src/OpenFOAM/containers/Lists/CompactListList/CompactListList.C
View file

@ -26,15 +26,10 @@ License
#include "CompactListList.H" #include "CompactListList.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
// * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * * //
template<class T> template<class T>
CompactListList<T>::CompactListList(const List<List<T> >& ll) Foam::CompactListList<T>::CompactListList(const List<List<T> >& ll)
: :
offsets_(ll.size()) offsets_(ll.size())
{ {
@ -61,7 +56,10 @@ CompactListList<T>::CompactListList(const List<List<T> >& ll)
template<class T> template<class T>
CompactListList<T>::CompactListList(const UList<label>& rowSizes) Foam::CompactListList<T>::CompactListList
(
const UList<label>& rowSizes
)
: :
offsets_(rowSizes.size()) offsets_(rowSizes.size())
{ {
@ -77,7 +75,11 @@ CompactListList<T>::CompactListList(const UList<label>& rowSizes)
template<class T> template<class T>
CompactListList<T>::CompactListList(const UList<label>& rowSizes, const T& t) Foam::CompactListList<T>::CompactListList
(
const UList<label>& rowSizes,
const T& t
)
: :
offsets_(rowSizes.size()) offsets_(rowSizes.size())
{ {
@ -93,25 +95,31 @@ CompactListList<T>::CompactListList(const UList<label>& rowSizes, const T& t)
template<class T> template<class T>
CompactListList<T>::CompactListList(CompactListList<T>& cll, bool reUse) Foam::CompactListList<T>::CompactListList
(
const Xfer<CompactListList<T> >& lst
)
{
transfer(lst());
}
template<class T>
Foam::CompactListList<T>::CompactListList
(
CompactListList<T>& lst,
bool reUse
)
: :
offsets_(cll.offsets_, reUse), offsets_(lst.offsets_, reUse),
m_(cll.m_, reUse) m_(lst.m_, reUse)
{} {}
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
template<class T> template<class T>
const CompactListList<T>& CompactListList<T>::null() void Foam::CompactListList<T>::setSize(const label nRows)
{
CompactListList<T>* nullPtr = reinterpret_cast<CompactListList<T>*>(NULL);
return *nullPtr;
}
template<class T>
void CompactListList<T>::setSize(const label nRows)
{ {
if (nRows == 0) if (nRows == 0)
{ {
@ -134,14 +142,19 @@ void CompactListList<T>::setSize(const label nRows)
template<class T> template<class T>
void CompactListList<T>::setSize(const label nRows, const label nData) void Foam::CompactListList<T>::setSize
(
const label nRows,
const label nData
)
{ {
offsets_.setSize(nRows); offsets_.setSize(nRows);
m_.setSize(nData); m_.setSize(nData);
} }
template<class T> template<class T>
void CompactListList<T>::setSize void Foam::CompactListList<T>::setSize
( (
const label nRows, const label nRows,
const label nData, const label nData,
@ -152,22 +165,9 @@ void CompactListList<T>::setSize
m_.setSize(nData, t); m_.setSize(nData, t);
} }
template<class T>
labelList CompactListList<T>::sizes() const
{
labelList rowSizes(offsets_.size());
label prevOffset = 0;
forAll(offsets_, i)
{
rowSizes[i] = offsets_[i]-prevOffset;
prevOffset = offsets_[i];
}
return rowSizes;
}
template<class T> template<class T>
void CompactListList<T>::setSize(const UList<label>& rowSizes) void Foam::CompactListList<T>::setSize(const UList<label>& rowSizes)
{ {
offsets_.setSize(rowSizes.size()); offsets_.setSize(rowSizes.size());
@ -181,8 +181,24 @@ void CompactListList<T>::setSize(const UList<label>& rowSizes)
m_.setSize(sumSize); m_.setSize(sumSize);
} }
template<class T> template<class T>
void CompactListList<T>::clear() Foam::labelList Foam::CompactListList<T>::sizes() const
{
labelList rowSizes(offsets_.size());
label prevOffset = 0;
forAll(offsets_, i)
{
rowSizes[i] = offsets_[i]-prevOffset;
prevOffset = offsets_[i];
}
return rowSizes;
}
template<class T>
void Foam::CompactListList<T>::clear()
{ {
offsets_.clear(); offsets_.clear();
m_.clear(); m_.clear();
@ -190,7 +206,7 @@ void CompactListList<T>::clear()
template<class T> template<class T>
void CompactListList<T>::transfer(CompactListList<T>& a) void Foam::CompactListList<T>::transfer(CompactListList<T>& a)
{ {
offsets_.transfer(a.offsets_); offsets_.transfer(a.offsets_);
m_.transfer(a.m_); m_.transfer(a.m_);
@ -200,34 +216,29 @@ void CompactListList<T>::transfer(CompactListList<T>& a)
// * * * * * * * * * * * * * * * Member Operators * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * Member Operators * * * * * * * * * * * * * //
template<class T> template<class T>
List<List<T> > CompactListList<T>::operator()() const Foam::List<Foam::List<T> > Foam::CompactListList<T>::operator()() const
{ {
List<List<T> > llt(offsets_.size()); List<List<T> > ll(offsets_.size());
label offsetPrev = 0; label offsetPrev = 0;
forAll(offsets_, i) forAll(offsets_, i)
{ {
List<T>& llti = llt[i]; List<T>& lst = ll[i];
llti.setSize(offsets_[i] - offsetPrev); lst.setSize(offsets_[i] - offsetPrev);
forAll(llti, j) forAll(lst, j)
{ {
llti[j] = m_[offsetPrev + j]; lst[j] = m_[offsetPrev + j];
} }
offsetPrev = offsets_[i]; offsetPrev = offsets_[i];
} }
return llt; return ll;
} }
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// * * * * * * * * * * * * * * * * IOStream operators * * * * * * * * * * * // // * * * * * * * * * * * * * * * * IOStream operators * * * * * * * * * * * //
#include "CompactListListIO.C" #include "CompactListListIO.C"

37
src/OpenFOAM/containers/Lists/CompactListList/CompactListList.H
View file

@ -81,6 +81,11 @@ class CompactListList
public: public:
// Static Member Functions
//- Return a null CompactListList
inline static const CompactListList<T>& null();
// Constructors // Constructors
//- Null constructor. //- Null constructor.
@ -103,6 +108,9 @@ public:
//- Construct given list of row-sizes //- Construct given list of row-sizes
CompactListList(const UList<label>& rowSizes, const T&); CompactListList(const UList<label>& rowSizes, const T&);
//- Construct by transferring the parameter contents
CompactListList(const Xfer<CompactListList<T> >&);
//- Construct as copy or re-use as specified. //- Construct as copy or re-use as specified.
CompactListList(CompactListList<T>&, bool reUse); CompactListList(CompactListList<T>&, bool reUse);
@ -113,16 +121,16 @@ public:
inline autoPtr<CompactListList<T> > clone() const; inline autoPtr<CompactListList<T> > clone() const;
// Member functions // Member Functions
//- Return a null CompactListList
static const CompactListList<T>& null();
// Access // Access
//- Return the primary size, i.e. the number of rows //- Return the primary size, i.e. the number of rows
inline label size() const; inline label size() const;
//- Return true if the number of rows is zero
inline bool empty() const;
//- Return the offset table //- Return the offset table
inline const List<label>& offsets() const; inline const List<label>& offsets() const;
@ -148,19 +156,34 @@ public:
//- Reset sizes of CompactListList and value for new elements. //- Reset sizes of CompactListList and value for new elements.
void setSize(const label nRows, const label nData, const T&); void setSize(const label nRows, const label nData, const T&);
//- Return sizes (to be used e.g. for construction)
labelList sizes() const;
//- Reset size of CompactListList. //- Reset size of CompactListList.
void setSize(const UList<label>& rowSizes); void setSize(const UList<label>& rowSizes);
//- Reset size of CompactListList.
// This form only allows contraction of the CompactListList.
inline void resize(const label nRows);
//- Reset size of CompactListList.
inline void resize(const label nRows, const label nData);
//- Reset sizes of CompactListList and value for new elements.
inline void resize(const label nRows, const label nData, const T&);
//- Reset size of CompactListList.
inline void resize(const UList<label>& rowSizes);
//- Clear the CompactListList, i.e. set sizes to zero. //- Clear the CompactListList, i.e. set sizes to zero.
void clear(); void clear();
//- Return sizes (to be used e.g. for construction)
labelList sizes() const;
//- Transfer the contents of the argument CompactListList //- Transfer the contents of the argument CompactListList
// into this CompactListList and annull the argument list. // into this CompactListList and annull the argument list.
void transfer(CompactListList<T>&); void transfer(CompactListList<T>&);
//- Transfer the contents to the Xfer container
inline Xfer<CompactListList<T> > xfer();
// Other // Other

167
src/OpenFOAM/containers/Lists/CompactListList/CompactListListI.H
View file

@ -24,20 +24,20 @@ License
\*---------------------------------------------------------------------------*/ \*---------------------------------------------------------------------------*/
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
template<class T> template<class T>
inline CompactListList<T>::CompactListList() inline Foam::CompactListList<T>::CompactListList()
{} {}
template<class T> template<class T>
inline CompactListList<T>::CompactListList(const label nRows, const label nData) inline Foam::CompactListList<T>::CompactListList
(
const label nRows,
const label nData
)
: :
offsets_(nRows, 0), offsets_(nRows, 0),
m_(nData) m_(nData)
@ -45,7 +45,7 @@ inline CompactListList<T>::CompactListList(const label nRows, const label nData)
template<class T> template<class T>
inline CompactListList<T>::CompactListList inline Foam::CompactListList<T>::CompactListList
( (
const label nRows, const label nRows,
const label nData, const label nData,
@ -58,7 +58,8 @@ inline CompactListList<T>::CompactListList
template<class T> template<class T>
inline autoPtr<CompactListList<T> > CompactListList<T>::clone() const inline Foam::autoPtr<Foam::CompactListList<T> >
Foam::CompactListList<T>::clone() const
{ {
return autoPtr<CompactListList<T> >(new CompactListList<T>(*this)); return autoPtr<CompactListList<T> >(new CompactListList<T>(*this));
} }
@ -67,38 +68,60 @@ inline autoPtr<CompactListList<T> > CompactListList<T>::clone() const
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
template<class T> template<class T>
inline label CompactListList<T>::size() const inline const Foam::CompactListList<T>& Foam::CompactListList<T>::null()
{
return *reinterpret_cast< CompactListList<T>* >(0);
}
template<class T>
inline Foam::label Foam::CompactListList<T>::size() const
{ {
return offsets_.size(); return offsets_.size();
} }
template<class T> template<class T>
inline const List<label>& CompactListList<T>::offsets() const inline bool Foam::CompactListList<T>::empty() const
{
return offsets_.empty();
}
template<class T>
inline const Foam::List<Foam::label>& Foam::CompactListList<T>::offsets() const
{ {
return offsets_; return offsets_;
} }
template<class T> template<class T>
inline List<label>& CompactListList<T>::offsets() inline Foam::List<Foam::label>& Foam::CompactListList<T>::offsets()
{ {
return offsets_; return offsets_;
} }
template<class T>
inline const List<T>& CompactListList<T>::m() const
{
return m_;
}
template<class T> template<class T>
inline List<T>& CompactListList<T>::m() inline const Foam::List<T>& Foam::CompactListList<T>::m() const
{ {
return m_; return m_;
} }
template<class T> template<class T>
inline label CompactListList<T>::index(const label i, const label j) const inline Foam::List<T>& Foam::CompactListList<T>::m()
{
return m_;
}
template<class T>
inline Foam::label Foam::CompactListList<T>::index
(
const label i,
const label j
) const
{ {
if (i == 0) if (i == 0)
{ {
@ -110,14 +133,15 @@ inline label CompactListList<T>::index(const label i, const label j) const
} }
} }
template<class T> template<class T>
inline label CompactListList<T>::whichRow(const label i) const inline Foam::label Foam::CompactListList<T>::whichRow(const label i) const
{ {
if (i < 0 || i >= m_.size()) if (i < 0 || i >= m_.size())
{ {
FatalErrorIn FatalErrorIn
( (
"CompactListList<T>::whichRow(const label i) const" "CompactListList<T>::whichRow(const label) const"
) << "Index " << i << " outside 0.." << m_.size() ) << "Index " << i << " outside 0.." << m_.size()
<< abort(FatalError); << abort(FatalError);
} }
@ -133,30 +157,69 @@ inline label CompactListList<T>::whichRow(const label i) const
return -1; return -1;
} }
template<class T> template<class T>
inline label CompactListList<T>::whichColumn(const label row, const label i) inline Foam::label Foam::CompactListList<T>::whichColumn
const (
const label row,
const label i
) const
{ {
return i - index(row, 0); return i - index(row, 0);
} }
template<class T>
inline Foam::Xfer<Foam::CompactListList<T> > Foam::CompactListList<T>::xfer()
{
return xferMove(*this);
}
template<class T>
inline void Foam::CompactListList<T>::resize(const label nRows)
{
this->setSize(nRows);
}
template<class T>
inline void Foam::CompactListList<T>::resize
(
const label nRows,
const label nData
)
{
this->setSize(nRows, nData);
}
template<class T>
inline void Foam::CompactListList<T>::resize
(
const label nRows,
const label nData,
const T& t
)
{
this->setSize(nRows, nData, t);
}
template<class T>
inline void Foam::CompactListList<T>::resize(const UList<label>& rowSizes)
{
this->setSize(rowSizes);
}
// * * * * * * * * * * * * * * * Member Operators * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * Member Operators * * * * * * * * * * * * * //
template<class T> template<class T>
inline UList<T> CompactListList<T>::operator[](const label i) inline Foam::UList<T> Foam::CompactListList<T>::operator[]
{ (
if (i == 0) const label i
{ )
return UList<T>(m_.begin(), offsets_[i]);
}
else
{
return UList<T>(&m_[offsets_[i-1]], offsets_[i] - offsets_[i-1]);
}
}
template<class T>
inline const UList<T> CompactListList<T>::operator[](const label i) const
{ {
if (i == 0) if (i == 0)
{ {
@ -170,13 +233,35 @@ inline const UList<T> CompactListList<T>::operator[](const label i) const
template<class T> template<class T>
inline T& CompactListList<T>::operator()(const label i, const label j) inline const Foam::UList<T> Foam::CompactListList<T>::operator[]
(
const label i
) const
{
if (i == 0)
{
return UList<T>(m_.begin(), offsets_[i]);
}
else
{
return UList<T>(&m_[offsets_[i-1]], offsets_[i] - offsets_[i-1]);
}
}
template<class T>
inline T& Foam::CompactListList<T>::operator()
(
const label i,
const label j
)
{ {
return m_[index(i, j)]; return m_[index(i, j)];
} }
template<class T> template<class T>
inline const T& CompactListList<T>::operator() inline const T& Foam::CompactListList<T>::operator()
( (
const label i, const label i,
const label j const label j
@ -187,14 +272,10 @@ inline const T& CompactListList<T>::operator()
template<class T> template<class T>
inline void CompactListList<T>::operator=(const T& t) inline void Foam::CompactListList<T>::operator=(const T& t)
{ {
m_ = t; m_ = t;
} }
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// ************************************************************************* // // ************************************************************************* //

19
src/OpenFOAM/containers/Lists/CompactListList/CompactListListIO.C
View file

@ -27,15 +27,10 @@ License
#include "CompactListList.H" #include "CompactListList.H"
#include "Istream.H" #include "Istream.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
// * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * * //
template<class T> template<class T>
CompactListList<T>::CompactListList(Istream& is) Foam::CompactListList<T>::CompactListList(Istream& is)
{ {
operator>>(is, *this); operator>>(is, *this);
} }
@ -44,23 +39,19 @@ CompactListList<T>::CompactListList(Istream& is)
// * * * * * * * * * * * * * * * IOstream Operators * * * * * * * * * * * * // // * * * * * * * * * * * * * * * IOstream Operators * * * * * * * * * * * * //
template<class T> template<class T>
Istream& operator>>(Istream& is, CompactListList<T>& cll) Foam::Istream& Foam::operator>>(Istream& is, CompactListList<T>& lst)
{ {
is >> cll.offsets_ >> cll.m_; is >> lst.offsets_ >> lst.m_;
return is; return is;
} }
template<class T> template<class T>
Ostream& operator<<(Ostream& os, const CompactListList<T>& cll) Foam::Ostream& Foam::operator<<(Ostream& os, const CompactListList<T>& lst)
{ {
os << cll.offsets_ << cll.m_; os << lst.offsets_ << lst.m_;
return os; return os;
} }
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// ************************************************************************* // // ************************************************************************* //

21
src/OpenFOAM/containers/Lists/DynamicList/DynamicList.C
View file

@ -28,26 +28,23 @@ License
// * * * * * * * * * * * * * * * IOstream Operators * * * * * * * * * * * * // // * * * * * * * * * * * * * * * IOstream Operators * * * * * * * * * * * * //
// Construct from Istream
template<class T, unsigned SizeInc, unsigned SizeMult, unsigned SizeDiv> template<class T, unsigned SizeInc, unsigned SizeMult, unsigned SizeDiv>
Foam::DynamicList<T, SizeInc, SizeMult, SizeDiv>::DynamicList(Istream& is) Foam::DynamicList<T, SizeInc, SizeMult, SizeDiv>::DynamicList(Istream& is)
: :
List<T>(is), List<T>(is),
nextFree_(List<T>::size()) capacity_(List<T>::size())
{} {}
template<class T, unsigned SizeInc, unsigned SizeMult, unsigned SizeDiv> template<class T, unsigned SizeInc, unsigned SizeMult, unsigned SizeDiv>
Foam::Ostream& Foam::operator<< Foam::Ostream& Foam::operator<<
( (
Foam::Ostream& os, Ostream& os,
const Foam::DynamicList<T, SizeInc, SizeMult, SizeDiv>& DL const DynamicList<T, SizeInc, SizeMult, SizeDiv>& lst
) )
{ {
const_cast<DynamicList<T, SizeInc, SizeMult, SizeDiv>&>(DL) os << static_cast<const List<T>&>(lst);
.setSize(DL.nextFree_);
os << static_cast<const List<T>&>(DL);
return os; return os;
} }
@ -55,12 +52,12 @@ Foam::Ostream& Foam::operator<<
template<class T, unsigned SizeInc, unsigned SizeMult, unsigned SizeDiv> template<class T, unsigned SizeInc, unsigned SizeMult, unsigned SizeDiv>
Foam::Istream& Foam::operator>> Foam::Istream& Foam::operator>>
( (
Foam::Istream& is, Istream& is,
Foam::DynamicList<T, SizeInc, SizeMult, SizeDiv>& DL DynamicList<T, SizeInc, SizeMult, SizeDiv>& lst
) )
{ {
is >> static_cast<List<T>&>(DL); is >> static_cast<List<T>&>(lst);
DL.nextFree_ = DL.List<T>::size(); lst.capacity_ = lst.List<T>::size();
return is; return is;
} }

Some files were not shown because too many files have changed in this diff Show more