zhyang-dev/OpenFOAM-6
1
0
Fork 0
mirror of https://github.com/OpenFOAM/OpenFOAM-6.git synced 2025-12-08 06:57:46 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Made all template declarations consistent using 'class' rather than 'typename'

Browse Source
This commit is contained in:
Henry Weller
2016-03-22 15:02:55 +00:00
parent 055a113f10
commit 44c73bfbe1
37 changed files with 114 additions and 114 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
applications/solvers/multiphase/reactingEulerFoam/interfacialCompositionModels/interfaceCompositionModels/InterfaceCompositionModel/InterfaceCompositionModel.H
View File

@ -45,8 +45,8 @@ namespace Foam
class phaseModel; class phaseModel;
class phasePair; class phasePair;
template <class ThermoType> class pureMixture; template<class ThermoType> class pureMixture;
template <class ThermoType> class multiComponentMixture; template<class ThermoType> class multiComponentMixture;
/*---------------------------------------------------------------------------*\ /*---------------------------------------------------------------------------*\
Class InterfaceCompositionModel Declaration Class InterfaceCompositionModel Declaration

2
applications/solvers/multiphase/reactingEulerFoam/phaseSystems/PhaseSystems/HeatAndMassTransferPhaseSystem/HeatAndMassTransferPhaseSystem.H
View File

@ -43,7 +43,7 @@ SourceFiles
namespace Foam namespace Foam
{ {
template <class modelType> template<class modelType>
class BlendedInterfacialModel; class BlendedInterfacialModel;
class blendingMethod; class blendingMethod;

2
applications/solvers/multiphase/reactingEulerFoam/phaseSystems/PhaseSystems/HeatTransferPhaseSystem/HeatTransferPhaseSystem.H
View File

@ -43,7 +43,7 @@ namespace Foam
{ {
class blendingMethod; class blendingMethod;
template <class modelType> class BlendedInterfacialModel; template<class modelType> class BlendedInterfacialModel;
class heatTransferModel; class heatTransferModel;
/*---------------------------------------------------------------------------*\ /*---------------------------------------------------------------------------*\

2
applications/solvers/multiphase/reactingEulerFoam/phaseSystems/PhaseSystems/MomentumTransferPhaseSystem/MomentumTransferPhaseSystem.H
View File

@ -47,7 +47,7 @@ SourceFiles
namespace Foam namespace Foam
{ {
template <class modelType> template<class modelType>
class BlendedInterfacialModel; class BlendedInterfacialModel;
class blendingMethod; class blendingMethod;

6
applications/solvers/multiphase/reactingEulerFoam/phaseSystems/phaseSystem/phaseSystem.H
View File

@ -57,7 +57,7 @@ namespace Foam
{ {
class blendingMethod; class blendingMethod;
template <class modelType> class BlendedInterfacialModel; template<class modelType> class BlendedInterfacialModel;
class surfaceTensionModel; class surfaceTensionModel;
class aspectRatioModel; class aspectRatioModel;
@ -320,11 +320,11 @@ public:
inline fv::options& fvOptions() const; inline fv::options& fvOptions() const;
//- Access a sub model between a phase pair //- Access a sub model between a phase pair
template <class modelType> template<class modelType>
const modelType& lookupSubModel(const phasePair& key) const; const modelType& lookupSubModel(const phasePair& key) const;
//- Access a sub model between two phases //- Access a sub model between two phases
template <class modelType> template<class modelType>
const modelType& lookupSubModel const modelType& lookupSubModel
( (
const phaseModel& dispersed, const phaseModel& dispersed,

4
applications/solvers/multiphase/reactingEulerFoam/phaseSystems/phaseSystem/phaseSystemTemplates.C
View File

@ -182,7 +182,7 @@ void Foam::phaseSystem::generatePairsAndSubModels
} }
} }
template <class modelType> template<class modelType>
const modelType& Foam::phaseSystem::lookupSubModel(const phasePair& key) const const modelType& Foam::phaseSystem::lookupSubModel(const phasePair& key) const
{ {
return return
@ -193,7 +193,7 @@ const modelType& Foam::phaseSystem::lookupSubModel(const phasePair& key) const
} }
template <class modelType> template<class modelType>
const modelType& Foam::phaseSystem::lookupSubModel const modelType& Foam::phaseSystem::lookupSubModel
( (
const phaseModel& dispersed, const phaseModel& dispersed,

2
applications/solvers/multiphase/twoPhaseEulerFoam/twoPhaseSystem/twoPhaseSystem.H
View File

@ -54,7 +54,7 @@ class wallLubricationModel;
class turbulentDispersionModel; class turbulentDispersionModel;
class blendingMethod; class blendingMethod;
template <class modelType> class BlendedInterfacialModel; template<class modelType> class BlendedInterfacialModel;
/*---------------------------------------------------------------------------*\ /*---------------------------------------------------------------------------*\
Class twoPhaseSystem Declaration Class twoPhaseSystem Declaration

18
applications/utilities/mesh/generation/foamyMesh/conformalVoronoiMesh/DelaunayMeshTools/DelaunayMeshTools.H
View File

@ -2,7 +2,7 @@
========= | ========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox \\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | \\ / O peration |
\\ / A nd | Copyright (C) 2013-2015 OpenFOAM Foundation \\ / A nd | Copyright (C) 2013-2016 OpenFOAM Foundation
\\/ M anipulation | \\/ M anipulation |
------------------------------------------------------------------------------- -------------------------------------------------------------------------------
License License
@ -75,7 +75,7 @@ namespace DelaunayMeshTools
//- Write Delaunay points in the range between (and including) //- Write Delaunay points in the range between (and including)
// type startPointType and endPointType to an OBJ file // type startPointType and endPointType to an OBJ file
template<typename Triangulation> template<class Triangulation>
void writeOBJ void writeOBJ
( (
const fileName& fName, const fileName& fName,
@ -85,7 +85,7 @@ namespace DelaunayMeshTools
); );
//- Write Delaunay points of type pointType to .obj file //- Write Delaunay points of type pointType to .obj file
template<typename Triangulation> template<class Triangulation>
void writeOBJ void writeOBJ
( (
const fileName& fName, const fileName& fName,
@ -94,15 +94,15 @@ namespace DelaunayMeshTools
); );
//- Write the fixed Delaunay points to an OBJ file //- Write the fixed Delaunay points to an OBJ file
template<typename Triangulation> template<class Triangulation>
void writeFixedPoints(const fileName& fName, const Triangulation& t); void writeFixedPoints(const fileName& fName, const Triangulation& t);
//- Write the boundary Delaunay points to an OBJ file //- Write the boundary Delaunay points to an OBJ file
template<typename Triangulation> template<class Triangulation>
void writeBoundaryPoints(const fileName& fName, const Triangulation& t); void writeBoundaryPoints(const fileName& fName, const Triangulation& t);
//- Write the processor interface to an OBJ file //- Write the processor interface to an OBJ file
template<typename Triangulation> template<class Triangulation>
void writeProcessorInterface void writeProcessorInterface
( (
const fileName& fName, const fileName& fName,
@ -112,7 +112,7 @@ namespace DelaunayMeshTools
//- Write the internal Delaunay vertices of the tessellation as a //- Write the internal Delaunay vertices of the tessellation as a
// pointField that may be used to restart the meshing process // pointField that may be used to restart the meshing process
template<typename Triangulation> template<class Triangulation>
void writeInternalDelaunayVertices void writeInternalDelaunayVertices
( (
const fileName& instance, const fileName& instance,
@ -121,14 +121,14 @@ namespace DelaunayMeshTools
//- Draws a tet cell to an output stream. The offset is supplied as the tet //- Draws a tet cell to an output stream. The offset is supplied as the tet
// number to be drawn. // number to be drawn.
template<typename CellHandle> template<class CellHandle>
void drawDelaunayCell(Ostream& os, const CellHandle& c, label offset = 0); void drawDelaunayCell(Ostream& os, const CellHandle& c, label offset = 0);
// Field extraction // Field extraction
//- Extract all points in vertex-index order //- Extract all points in vertex-index order
template<typename Triangulation> template<class Triangulation>
tmp<pointField> allPoints(const Triangulation& t); tmp<pointField> allPoints(const Triangulation& t);

16
applications/utilities/mesh/generation/foamyMesh/conformalVoronoiMesh/DelaunayMeshTools/DelaunayMeshToolsTemplates.C
View File

@ -32,7 +32,7 @@ License
// * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * * // // * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * * //
template<typename Triangulation> template<class Triangulation>
void Foam::DelaunayMeshTools::writeOBJ void Foam::DelaunayMeshTools::writeOBJ
( (
const fileName& fName, const fileName& fName,
@ -77,7 +77,7 @@ void Foam::DelaunayMeshTools::writeOBJ
} }
template<typename Triangulation> template<class Triangulation>
void Foam::DelaunayMeshTools::writeOBJ void Foam::DelaunayMeshTools::writeOBJ
( (
const fileName& fName, const fileName& fName,
@ -89,7 +89,7 @@ void Foam::DelaunayMeshTools::writeOBJ
} }
template<typename Triangulation> template<class Triangulation>
void Foam::DelaunayMeshTools::writeFixedPoints void Foam::DelaunayMeshTools::writeFixedPoints
( (
const fileName& fName, const fileName& fName,
@ -117,7 +117,7 @@ void Foam::DelaunayMeshTools::writeFixedPoints
} }
template<typename Triangulation> template<class Triangulation>
void Foam::DelaunayMeshTools::writeBoundaryPoints void Foam::DelaunayMeshTools::writeBoundaryPoints
( (
const fileName& fName, const fileName& fName,
@ -145,7 +145,7 @@ void Foam::DelaunayMeshTools::writeBoundaryPoints
} }
template<typename Triangulation> template<class Triangulation>
void Foam::DelaunayMeshTools::writeProcessorInterface void Foam::DelaunayMeshTools::writeProcessorInterface
( (
const fileName& fName, const fileName& fName,
@ -175,7 +175,7 @@ void Foam::DelaunayMeshTools::writeProcessorInterface
} }
template<typename Triangulation> template<class Triangulation>
void Foam::DelaunayMeshTools::writeInternalDelaunayVertices void Foam::DelaunayMeshTools::writeInternalDelaunayVertices
( (
const fileName& instance, const fileName& instance,
@ -224,7 +224,7 @@ void Foam::DelaunayMeshTools::writeInternalDelaunayVertices
} }
template<typename CellHandle> template<class CellHandle>
void Foam::DelaunayMeshTools::drawDelaunayCell void Foam::DelaunayMeshTools::drawDelaunayCell
( (
Ostream& os, Ostream& os,
@ -273,7 +273,7 @@ void Foam::DelaunayMeshTools::drawDelaunayCell
} }
template<typename Triangulation> template<class Triangulation>
Foam::tmp<Foam::pointField> Foam::DelaunayMeshTools::allPoints Foam::tmp<Foam::pointField> Foam::DelaunayMeshTools::allPoints
( (
const Triangulation& t const Triangulation& t

4
applications/utilities/mesh/generation/foamyMesh/conformalVoronoiMesh/backgroundMeshDecomposition/backgroundMeshDecomposition.H
View File

@ -225,7 +225,7 @@ public:
); );
//- Distribute supplied the points to the appropriate processor //- Distribute supplied the points to the appropriate processor
template<typename PointType> template<class PointType>
autoPtr<mapDistribute> distributePoints(List<PointType>& points) const; autoPtr<mapDistribute> distributePoints(List<PointType>& points) const;
//- Is the given position inside the domain of this decomposition //- Is the given position inside the domain of this decomposition
@ -263,7 +263,7 @@ public:
) const; ) const;
//- What processor is the given position on? //- What processor is the given position on?
template<typename PointType> template<class PointType>
labelList processorPosition(const List<PointType>& pts) const; labelList processorPosition(const List<PointType>& pts) const;
//- What is the nearest processor to the given position? //- What is the nearest processor to the given position?

6
applications/utilities/mesh/generation/foamyMesh/conformalVoronoiMesh/backgroundMeshDecomposition/backgroundMeshDecompositionTemplates.C
View File

@ -2,7 +2,7 @@
========= | ========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox \\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | \\ / O peration |
\\ / A nd | Copyright (C) 2013-2015 OpenFOAM Foundation \\ / A nd | Copyright (C) 2013-2016 OpenFOAM Foundation
\\/ M anipulation | \\/ M anipulation |
------------------------------------------------------------------------------- -------------------------------------------------------------------------------
License License
@ -28,7 +28,7 @@ License
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
template<typename PointType> template<class PointType>
Foam::autoPtr<Foam::mapDistribute> Foam::autoPtr<Foam::mapDistribute>
Foam::backgroundMeshDecomposition::distributePoints Foam::backgroundMeshDecomposition::distributePoints
( (
@ -45,7 +45,7 @@ Foam::backgroundMeshDecomposition::distributePoints
} }
template<typename PointType> template<class PointType>
Foam::labelList Foam::backgroundMeshDecomposition::processorPosition Foam::labelList Foam::backgroundMeshDecomposition::processorPosition
( (
const List<PointType>& pts const List<PointType>& pts

2
applications/utilities/mesh/generation/foamyMesh/conformalVoronoiMesh/conformalVoronoiMesh/indexedCell/indexedCell.H
View File

@ -119,7 +119,7 @@ public:
typedef typename Cb::Vertex_handle Vertex_handle; typedef typename Cb::Vertex_handle Vertex_handle;
typedef typename Cb::Cell_handle Cell_handle; typedef typename Cb::Cell_handle Cell_handle;
template<typename TDS2> template<class TDS2>
struct Rebind_TDS struct Rebind_TDS
{ {
typedef typename Cb::template Rebind_TDS<TDS2>::Other Cb2; typedef typename Cb::template Rebind_TDS<TDS2>::Other Cb2;

8
applications/utilities/mesh/generation/foamyMesh/conformalVoronoiMesh/conformalVoronoiMesh/indexedCell/indexedCellChecks.C
View File

@ -2,7 +2,7 @@
========= | ========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox \\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | \\ / O peration |
\\ / A nd | Copyright (C) 2012-2015 OpenFOAM Foundation \\ / A nd | Copyright (C) 2012-2016 OpenFOAM Foundation
\\/ M anipulation | \\/ M anipulation |
------------------------------------------------------------------------------- -------------------------------------------------------------------------------
License License
@ -29,7 +29,7 @@ License
#include "CGALTriangulation3DKernel.H" #include "CGALTriangulation3DKernel.H"
template<typename Cell> template<class Cell>
Foam::scalar Foam::foamyHexMeshChecks::coplanarTet Foam::scalar Foam::foamyHexMeshChecks::coplanarTet
( (
Cell& c, Cell& c,
@ -74,7 +74,7 @@ Foam::scalar Foam::foamyHexMeshChecks::coplanarTet
} }
template<typename Cell> template<class Cell>
bool Foam::foamyHexMeshChecks::closePoints bool Foam::foamyHexMeshChecks::closePoints
( (
Cell& c, Cell& c,
@ -104,7 +104,7 @@ bool Foam::foamyHexMeshChecks::closePoints
} }
template<typename Cell> template<class Cell>
bool Foam::foamyHexMeshChecks::smallVolume bool Foam::foamyHexMeshChecks::smallVolume
( (
Cell& c, Cell& c,

8
applications/utilities/mesh/generation/foamyMesh/conformalVoronoiMesh/conformalVoronoiMesh/indexedCell/indexedCellChecks.H
View File

@ -2,7 +2,7 @@
========= | ========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox \\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | \\ / O peration |
\\ / A nd | Copyright (C) 2012-2015 OpenFOAM Foundation \\ / A nd | Copyright (C) 2012-2016 OpenFOAM Foundation
\\/ M anipulation | \\/ M anipulation |
------------------------------------------------------------------------------- -------------------------------------------------------------------------------
License License
@ -34,21 +34,21 @@ namespace Foam
namespace foamyHexMeshChecks namespace foamyHexMeshChecks
{ {
template<typename Cell> template<class Cell>
scalar coplanarTet scalar coplanarTet
( (
Cell& c, Cell& c,
const scalar tol = 1e-12 const scalar tol = 1e-12
); );
template<typename Cell> template<class Cell>
bool closePoints bool closePoints
( (
Cell& c, Cell& c,
const scalar tol = 1e-12 const scalar tol = 1e-12
); );
template<typename Cell> template<class Cell>
bool smallVolume bool smallVolume
( (
Cell& c, Cell& c,

6
applications/utilities/mesh/generation/foamyMesh/conformalVoronoiMesh/conformalVoronoiMesh/indexedCell/indexedCellOps.H
View File

@ -2,7 +2,7 @@
========= | ========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox \\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | \\ / O peration |
\\ / A nd | Copyright (C) 2013-2015 OpenFOAM Foundation \\ / A nd | Copyright (C) 2013-2016 OpenFOAM Foundation
\\/ M anipulation | \\/ M anipulation |
------------------------------------------------------------------------------- -------------------------------------------------------------------------------
License License
@ -50,10 +50,10 @@ namespace indexedCellOps
{ {
//- Does the Dual vertex form part of a processor patch //- Does the Dual vertex form part of a processor patch
template<typename CellType> template<class CellType>
Foam::label dualVertexMasterProc(const CellType& c); Foam::label dualVertexMasterProc(const CellType& c);
template<typename CellType> template<class CellType>
Foam::FixedList<Foam::label, 4> processorsAttached(const CellType& c); Foam::FixedList<Foam::label, 4> processorsAttached(const CellType& c);
} // End namespace indexedCellOps } // End namespace indexedCellOps

6
applications/utilities/mesh/generation/foamyMesh/conformalVoronoiMesh/conformalVoronoiMesh/indexedCell/indexedCellOpsTemplates.C
View File

@ -2,7 +2,7 @@
========= | ========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox \\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | \\ / O peration |
\\ / A nd | Copyright (C) 2013-2015 OpenFOAM Foundation \\ / A nd | Copyright (C) 2013-2016 OpenFOAM Foundation
\\/ M anipulation | \\/ M anipulation |
------------------------------------------------------------------------------- -------------------------------------------------------------------------------
License License
@ -28,7 +28,7 @@ License
// * * * * * * * * * * * * * * * Global Functions * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * Global Functions * * * * * * * * * * * * * //
template<typename CellType> template<class CellType>
Foam::label CGAL::indexedCellOps::dualVertexMasterProc(const CellType& c) Foam::label CGAL::indexedCellOps::dualVertexMasterProc(const CellType& c)
{ {
if (!c->parallelDualVertex()) if (!c->parallelDualVertex())
@ -56,7 +56,7 @@ Foam::label CGAL::indexedCellOps::dualVertexMasterProc(const CellType& c)
} }
template<typename CellType> template<class CellType>
Foam::FixedList<Foam::label, 4> Foam::FixedList<Foam::label, 4>
CGAL::indexedCellOps::processorsAttached(const CellType& c) CGAL::indexedCellOps::processorsAttached(const CellType& c)
{ {

2
applications/utilities/mesh/generation/foamyMesh/conformalVoronoiMesh/conformalVoronoiMesh/indexedVertex/indexedVertex.H
View File

@ -134,7 +134,7 @@ public:
typedef typename Tds::Vertex_handle Vertex_handle; typedef typename Tds::Vertex_handle Vertex_handle;
typedef typename Tds::Cell_handle Cell_handle; typedef typename Tds::Cell_handle Cell_handle;
template<typename TDS2> template<class TDS2>
struct Rebind_TDS struct Rebind_TDS
{ {
typedef typename Vb::template Rebind_TDS<TDS2>::Other Vb2; typedef typename Vb::template Rebind_TDS<TDS2>::Other Vb2;

6
applications/utilities/mesh/generation/foamyMesh/conformalVoronoiMesh/conformalVoronoiMesh/indexedVertex/indexedVertexOps.H
View File

@ -2,7 +2,7 @@
========= | ========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox \\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | \\ / O peration |
\\ / A nd | Copyright (C) 2013-2015 OpenFOAM Foundation \\ / A nd | Copyright (C) 2013-2016 OpenFOAM Foundation
\\/ M anipulation | \\/ M anipulation |
------------------------------------------------------------------------------- -------------------------------------------------------------------------------
License License
@ -50,11 +50,11 @@ namespace indexedVertexOps
//- Return the target cell size from that stored on a pair of Delaunay vertices, //- Return the target cell size from that stored on a pair of Delaunay vertices,
// using a mean function. // using a mean function.
template<typename VertexType> template<class VertexType>
Foam::scalar averageCellSize(const VertexType& vA, const VertexType& vB); Foam::scalar averageCellSize(const VertexType& vA, const VertexType& vB);
template<typename VertexType> template<class VertexType>
inline bool uninitialised(const VertexType& v); inline bool uninitialised(const VertexType& v);
} // End namespace indexedVertexOps } // End namespace indexedVertexOps

6
applications/utilities/mesh/generation/foamyMesh/conformalVoronoiMesh/conformalVoronoiMesh/indexedVertex/indexedVertexOpsTemplates.C
View File

@ -2,7 +2,7 @@
========= | ========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox \\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | \\ / O peration |
\\ / A nd | Copyright (C) 2013-2015 OpenFOAM Foundation \\ / A nd | Copyright (C) 2013-2016 OpenFOAM Foundation
\\/ M anipulation | \\/ M anipulation |
------------------------------------------------------------------------------- -------------------------------------------------------------------------------
License License
@ -27,7 +27,7 @@ License
// * * * * * * * * * * * * * * * Global Functions * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * Global Functions * * * * * * * * * * * * * //
template<typename VertexType> template<class VertexType>
Foam::scalar CGAL::indexedVertexOps::averageCellSize Foam::scalar CGAL::indexedVertexOps::averageCellSize
( (
const VertexType& vA, const VertexType& vA,
@ -47,7 +47,7 @@ Foam::scalar CGAL::indexedVertexOps::averageCellSize
} }
template<typename VertexType> template<class VertexType>
inline bool CGAL::indexedVertexOps::uninitialised(const VertexType& v) inline bool CGAL::indexedVertexOps::uninitialised(const VertexType& v)
{ {
return v->type() == Foam::indexedVertexEnum::vtUnassigned; return v->type() == Foam::indexedVertexEnum::vtUnassigned;

4
applications/utilities/mesh/generation/foamyMesh/conformalVoronoiMesh/conformalVoronoiMesh/pointConversion.H
View File

@ -54,7 +54,7 @@ namespace Foam
#ifdef CGAL_INEXACT #ifdef CGAL_INEXACT
template<typename Point> template<class Point>
inline pointFromPoint topoint(const Point& P) inline pointFromPoint topoint(const Point& P)
{ {
return reinterpret_cast<pointFromPoint>(P); return reinterpret_cast<pointFromPoint>(P);
@ -67,7 +67,7 @@ namespace Foam
#else #else
template<typename Point> template<class Point>
inline pointFromPoint topoint(const Point& P) inline pointFromPoint topoint(const Point& P)
{ {
return Foam::point return Foam::point

16
applications/utilities/mesh/generation/foamyMesh/conformalVoronoiMesh/vectorTools/vectorTools.H
View File

@ -2,7 +2,7 @@
========= | ========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox \\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | \\ / O peration |
\\ / A nd | Copyright (C) 2011-2015 OpenFOAM Foundation \\ / A nd | Copyright (C) 2011-2016 OpenFOAM Foundation
\\/ M anipulation | \\/ M anipulation |
------------------------------------------------------------------------------- -------------------------------------------------------------------------------
License License
@ -50,7 +50,7 @@ namespace vectorTools
//- Test if a and b are parallel: a^b = 0 //- Test if a and b are parallel: a^b = 0
// Uses the cross product, so the tolerance is proportional to // Uses the cross product, so the tolerance is proportional to
// the sine of the angle between a and b in radians // the sine of the angle between a and b in radians
template<typename T> template<class T>
bool areParallel bool areParallel
( (
const Vector<T>& a, const Vector<T>& a,
@ -67,7 +67,7 @@ namespace vectorTools
//- Test if a and b are orthogonal: a.b = 0 //- Test if a and b are orthogonal: a.b = 0
// Uses the dot product, so the tolerance is proportional to // Uses the dot product, so the tolerance is proportional to
// the cosine of the angle between a and b in radians // the cosine of the angle between a and b in radians
template<typename T> template<class T>
bool areOrthogonal bool areOrthogonal
( (
const Vector<T>& a, const Vector<T>& a,
@ -79,7 +79,7 @@ namespace vectorTools
} }
//- Test if angle between a and b is acute: a.b > 0 //- Test if angle between a and b is acute: a.b > 0
template<typename T> template<class T>
bool areAcute bool areAcute
( (
const Vector<T>& a, const Vector<T>& a,
@ -90,7 +90,7 @@ namespace vectorTools
} }
//- Test if angle between a and b is obtuse: a.b < 0 //- Test if angle between a and b is obtuse: a.b < 0
template<typename T> template<class T>
bool areObtuse bool areObtuse
( (
const Vector<T>& a, const Vector<T>& a,
@ -101,7 +101,7 @@ namespace vectorTools
} }
//- Calculate angle between a and b in radians //- Calculate angle between a and b in radians
template<typename T> template<class T>
T cosPhi T cosPhi
( (
const Vector<T>& a, const Vector<T>& a,
@ -116,7 +116,7 @@ namespace vectorTools
} }
//- Calculate angle between a and b in radians //- Calculate angle between a and b in radians
template<typename T> template<class T>
T radAngleBetween T radAngleBetween
( (
const Vector<T>& a, const Vector<T>& a,
@ -131,7 +131,7 @@ namespace vectorTools
} }
//- Calculate angle between a and b in degrees //- Calculate angle between a and b in degrees
template<typename T> template<class T>
T degAngleBetween T degAngleBetween
( (
const Vector<T>& a, const Vector<T>& a,

2
applications/utilities/mesh/generation/foamyMesh/foamyQuadMesh/indexedFace.H
View File

@ -70,7 +70,7 @@ public:
typedef typename Fb::Vertex_handle Vertex_handle; typedef typename Fb::Vertex_handle Vertex_handle;
typedef typename Fb::Face_handle Face_handle; typedef typename Fb::Face_handle Face_handle;
template<typename TDS2> template<class TDS2>
struct Rebind_TDS struct Rebind_TDS
{ {
typedef typename Fb::template Rebind_TDS<TDS2>::Other Fb2; typedef typename Fb::template Rebind_TDS<TDS2>::Other Fb2;

2
applications/utilities/mesh/generation/foamyMesh/foamyQuadMesh/indexedVertex.H
View File

@ -105,7 +105,7 @@ public:
typedef typename Vb::Face_handle Face_handle; typedef typename Vb::Face_handle Face_handle;
typedef typename Vb::Point Point; typedef typename Vb::Point Point;
template<typename TDS2> template<class TDS2>
struct Rebind_TDS struct Rebind_TDS
{ {
typedef typename Vb::template Rebind_TDS<TDS2>::Other Vb2; typedef typename Vb::template Rebind_TDS<TDS2>::Other Vb2;

2
applications/utilities/parallelProcessing/decomposePar/domainDecomposition.H
View File

@ -142,7 +142,7 @@ class domainDecomposition
) const; ) const;
//- Generate sub patch info for processor cyclics //- Generate sub patch info for processor cyclics
template <class BinaryOp> template<class BinaryOp>
void processInterCyclics void processInterCyclics
( (
const polyBoundaryMesh& patches, const polyBoundaryMesh& patches,

2
applications/utilities/parallelProcessing/decomposePar/domainDecompositionTemplates.C
View File

@ -27,7 +27,7 @@ License
// * * * * * * * * * * * * * Private Member Functions * * * * * * * * * * * // // * * * * * * * * * * * * * Private Member Functions * * * * * * * * * * * //
template <class BinaryOp> template<class BinaryOp>
void Foam::domainDecomposition::processInterCyclics void Foam::domainDecomposition::processInterCyclics
( (
const polyBoundaryMesh& patches, const polyBoundaryMesh& patches,

22
applications/utilities/surface/surfaceCoarsen/bunnylod/list.h
View File

@ -9,7 +9,7 @@
#include <assert.h> #include <assert.h>
#include <stdio.h> #include <stdio.h>
template <class Type> class List { template<class Type> class List {
public: public:
List(int s=0); List(int s=0);
~List(); ~List();
@ -30,7 +30,7 @@ template <class Type> class List {
}; };
template <class Type> template<class Type>
List<Type>::List(int s){ List<Type>::List(int s){
num=0; num=0;
array_size = 0; array_size = 0;
@ -40,12 +40,12 @@ List<Type>::List(int s){
} }
} }
template <class Type> template<class Type>
List<Type>::~List(){ List<Type>::~List(){
delete element; delete element;
} }
template <class Type> template<class Type>
void List<Type>::allocate(int s){ void List<Type>::allocate(int s){
assert(s>0); assert(s>0);
assert(s>=num); assert(s>=num);
@ -58,18 +58,18 @@ void List<Type>::allocate(int s){
} }
if(old) delete old; if(old) delete old;
} }
template <class Type> template<class Type>
void List<Type>::SetSize(int s){ void List<Type>::SetSize(int s){
if(s==0) { if(element) delete element;} if(s==0) { if(element) delete element;}
else { allocate(s); } else { allocate(s); }
num=s; num=s;
} }
template <class Type> template<class Type>
void List<Type>::Pack(){ void List<Type>::Pack(){
allocate(num); allocate(num);
} }
template <class Type> template<class Type>
void List<Type>::Add(Type t){ void List<Type>::Add(Type t){
assert(num<=array_size); assert(num<=array_size);
if(num==array_size) { if(num==array_size) {
@ -83,7 +83,7 @@ void List<Type>::Add(Type t){
element[num++] = t; element[num++] = t;
} }
template <class Type> template<class Type>
int List<Type>::Contains(Type t){ int List<Type>::Contains(Type t){
int i; int i;
int count=0; int count=0;
@ -93,13 +93,13 @@ int List<Type>::Contains(Type t){
return count; return count;
} }
template <class Type> template<class Type>
void List<Type>::AddUnique(Type t){ void List<Type>::AddUnique(Type t){
if(!Contains(t)) Add(t); if(!Contains(t)) Add(t);
} }
template <class Type> template<class Type>
void List<Type>::DelIndex(int i){ void List<Type>::DelIndex(int i){
assert(i<num); assert(i<num);
num--; num--;
@ -109,7 +109,7 @@ void List<Type>::DelIndex(int i){
} }
} }
template <class Type> template<class Type>
void List<Type>::Remove(Type t){ void List<Type>::Remove(Type t){
int i; int i;
for(i=0;i<num;i++) { for(i=0;i<num;i++) {

2
src/OpenFOAM/db/IOstreams/Pstreams/Pstream.H
View File

@ -123,7 +123,7 @@ public:
); );
//- Like above but switches between linear/tree communication //- Like above but switches between linear/tree communication
template <class T> template<class T>
static void scatter static void scatter
( (
T& Value, T& Value,

8
src/OpenFOAM/db/IOstreams/Pstreams/combineGatherScatter.C
View File

@ -134,7 +134,7 @@ void Foam::Pstream::combineGather
} }
template <class T, class CombineOp> template<class T, class CombineOp>
void Foam::Pstream::combineGather void Foam::Pstream::combineGather
( (
T& Value, T& Value,
@ -249,7 +249,7 @@ void Foam::Pstream::combineScatter
} }
template <class T> template<class T>
void Foam::Pstream::combineScatter void Foam::Pstream::combineScatter
( (
T& Value, T& Value,
@ -484,7 +484,7 @@ void Foam::Pstream::listCombineScatter
} }
template <class T> template<class T>
void Foam::Pstream::listCombineScatter void Foam::Pstream::listCombineScatter
( (
List<T>& Values, List<T>& Values,
@ -667,7 +667,7 @@ void Foam::Pstream::mapCombineScatter
} }
template <class Container> template<class Container>
void Foam::Pstream::mapCombineScatter void Foam::Pstream::mapCombineScatter
( (
Container& Values, Container& Values,

6
src/OpenFOAM/db/IOstreams/Pstreams/gatherScatter.C
View File

@ -2,7 +2,7 @@
========= | ========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox \\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | \\ / O peration |
\\ / A nd | Copyright (C) 2011-2013 OpenFOAM Foundation \\ / A nd | Copyright (C) 2011-2016 OpenFOAM Foundation
\\/ M anipulation | \\/ M anipulation |
------------------------------------------------------------------------------- -------------------------------------------------------------------------------
License License
@ -122,7 +122,7 @@ void Pstream::gather
} }
template <class T, class BinaryOp> template<class T, class BinaryOp>
void Pstream::gather void Pstream::gather
( (
T& Value, T& Value,
@ -217,7 +217,7 @@ void Pstream::scatter
} }
template <class T> template<class T>
void Pstream::scatter(T& Value, const int tag, const label comm) void Pstream::scatter(T& Value, const int tag, const label comm)
{ {
if (UPstream::nProcs(comm) < UPstream::nProcsSimpleSum) if (UPstream::nProcs(comm) < UPstream::nProcsSimpleSum)

6
src/OpenFOAM/db/IOstreams/Pstreams/gatherScatterList.C
View File

@ -2,7 +2,7 @@
========= | ========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox \\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | \\ / O peration |
\\ / A nd | Copyright (C) 2011-2015 OpenFOAM Foundation \\ / A nd | Copyright (C) 2011-2016 OpenFOAM Foundation
\\/ M anipulation | \\/ M anipulation |
------------------------------------------------------------------------------- -------------------------------------------------------------------------------
License License
@ -186,7 +186,7 @@ void Pstream::gatherList
} }
template <class T> template<class T>
void Pstream::gatherList(List<T>& Values, const int tag, const label comm) void Pstream::gatherList(List<T>& Values, const int tag, const label comm)
{ {
if (UPstream::nProcs(comm) < UPstream::nProcsSimpleSum) if (UPstream::nProcs(comm) < UPstream::nProcsSimpleSum)
@ -321,7 +321,7 @@ void Pstream::scatterList
} }
template <class T> template<class T>
void Pstream::scatterList(List<T>& Values, const int tag, const label comm) void Pstream::scatterList(List<T>& Values, const int tag, const label comm)
{ {
if (UPstream::nProcs(comm) < UPstream::nProcsSimpleSum) if (UPstream::nProcs(comm) < UPstream::nProcsSimpleSum)

4
src/OpenFOAM/memory/tmp/tmpI.H
View File

@ -372,7 +372,7 @@ inline void Foam::tmp<T>::operator=(const tmp<T>& t)
//- Return the const reference of the non-const reference argument //- Return the const reference of the non-const reference argument
template<typename T> template<class T>
inline const T& Const(T& t) inline const T& Const(T& t)
{ {
return t; return t;
@ -380,7 +380,7 @@ inline const T& Const(T& t)
//- Return the const reference of the non-const rvalue reference argument //- Return the const reference of the non-const rvalue reference argument
template<typename T> template<class T>
inline const T& Const(T&& t) inline const T& Const(T&& t)
{ {
return t; return t;

4
src/OpenFOAM/memory/tmpNrc/tmpNrcI.H
View File

@ -302,7 +302,7 @@ inline void Foam::tmpNrc<T>::operator=(const tmpNrc<T>& t)
//- Return the const reference of the non-const reference argument //- Return the const reference of the non-const reference argument
template<typename T> template<class T>
inline const T& Const(T& t) inline const T& Const(T& t)
{ {
return t; return t;
@ -310,7 +310,7 @@ inline const T& Const(T& t)
//- Return the const reference of the non-const rvalue reference argument //- Return the const reference of the non-const rvalue reference argument
template<typename T> template<class T>
inline const T& Const(T&& t) inline const T& Const(T&& t)
{ {
return t; return t;

12
src/OpenFOAM/primitives/nullObject/nullObject.H
View File

@ -69,29 +69,29 @@ extern const NullObject* nullObjectPtr;
//- Return reference to the nullObject of type T //- Return reference to the nullObject of type T
template <class T> template<class T>
inline const T& NullObjectRef(); inline const T& NullObjectRef();
//- Return pointer to the nullObject of type T //- Return pointer to the nullObject of type T
template <class T> template<class T>
inline const T* NullObjectPtr(); inline const T* NullObjectPtr();
//- Return true if t is a reference to the nullObject of type T //- Return true if t is a reference to the nullObject of type T
template <class T> template<class T>
inline bool isNull(const T& t); inline bool isNull(const T& t);
//- Return true if t is not a reference to the nullObject of type T //- Return true if t is not a reference to the nullObject of type T
template <class T> template<class T>
inline bool notNull(const T& t); inline bool notNull(const T& t);
//- Return true if t is a pointer to the nullObject of type T //- Return true if t is a pointer to the nullObject of type T
template <class T> template<class T>
inline bool isNull(const T* t); inline bool isNull(const T* t);
//- Return true if t is not a pointer to the nullObject of type T //- Return true if t is not a pointer to the nullObject of type T
template <class T> template<class T>
inline bool notNull(const T* t); inline bool notNull(const T* t);

14
src/OpenFOAM/primitives/nullObject/nullObjectI.H
View File

@ -2,7 +2,7 @@
========= | ========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox \\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | \\ / O peration |
\\ / A nd | Copyright (C) 2014 OpenFOAM Foundation \\ / A nd | Copyright (C) 2014-2016 OpenFOAM Foundation
\\/ M anipulation | \\/ M anipulation |
------------------------------------------------------------------------------- -------------------------------------------------------------------------------
License License
@ -23,39 +23,39 @@ License
\*---------------------------------------------------------------------------*/ \*---------------------------------------------------------------------------*/
template <class T> template<class T>
inline const T& Foam::NullObjectRef() inline const T& Foam::NullObjectRef()
{ {
return *reinterpret_cast<const T*>(nullObjectPtr); return *reinterpret_cast<const T*>(nullObjectPtr);
} }
template <class T> template<class T>
inline const T* Foam::NullObjectPtr() inline const T* Foam::NullObjectPtr()
{ {
return reinterpret_cast<const T*>(nullObjectPtr); return reinterpret_cast<const T*>(nullObjectPtr);
} }
template <class T> template<class T>
inline bool Foam::isNull(const T& t) inline bool Foam::isNull(const T& t)
{ {
return &t == NullObjectPtr<T>(); return &t == NullObjectPtr<T>();
} }
template <class T> template<class T>
inline bool Foam::notNull(const T& t) inline bool Foam::notNull(const T& t)
{ {
return &t != NullObjectPtr<T>(); return &t != NullObjectPtr<T>();
} }
template <class T> template<class T>
inline bool Foam::isNull(const T* t) inline bool Foam::isNull(const T* t)
{ {
return t == NullObjectPtr<T>(); return t == NullObjectPtr<T>();
} }
template <class T> template<class T>
inline bool Foam::notNull(const T* t) inline bool Foam::notNull(const T* t)
{ {
return t != NullObjectPtr<T>(); return t != NullObjectPtr<T>();

4
src/dynamicMesh/polyMeshFilter/polyMeshFilter.H
View File

@ -89,10 +89,10 @@ class polyMeshFilter
// Private Member Functions // Private Member Functions
template<typename T> template<class T>
static void updateSets(const mapPolyMesh& map); static void updateSets(const mapPolyMesh& map);
template<typename T> template<class T>
static void copySets(const polyMesh& oldMesh, const polyMesh& newMesh); static void copySets(const polyMesh& oldMesh, const polyMesh& newMesh);
label filterFacesLoop(const label nOriginalBadFaces); label filterFacesLoop(const label nOriginalBadFaces);

6
src/dynamicMesh/polyMeshFilter/polyMeshFilterTemplates.C
View File

@ -2,7 +2,7 @@
========= | ========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox \\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | \\ / O peration |
\\ / A nd | Copyright (C) 2013 OpenFOAM Foundation \\ / A nd | Copyright (C) 2013-2016 OpenFOAM Foundation
\\/ M anipulation | \\/ M anipulation |
------------------------------------------------------------------------------- -------------------------------------------------------------------------------
License License
@ -30,7 +30,7 @@ License
// * * * * * * * * * * * * * Public Member Functions * * * * * * * * * * * * // // * * * * * * * * * * * * * Public Member Functions * * * * * * * * * * * * //
template<typename SetType> template<class SetType>
void Foam::polyMeshFilter::updateSets(const mapPolyMesh& map) void Foam::polyMeshFilter::updateSets(const mapPolyMesh& map)
{ {
HashTable<const SetType*> sets = HashTable<const SetType*> sets =
@ -66,7 +66,7 @@ void Foam::polyMeshFilter::updateSets(const mapPolyMesh& map)
} }
template<typename SetType> template<class SetType>
void Foam::polyMeshFilter::copySets void Foam::polyMeshFilter::copySets
( (
const polyMesh& oldMesh, const polyMesh& oldMesh,

2
src/lagrangian/intermediate/submodels/MPPIC/PackingModels/PackingModel/PackingModel.H
View File

@ -52,7 +52,7 @@ class ParticleStressModel;
class CorrectionLimitingMethod; class CorrectionLimitingMethod;
template <class Type> template<class Type>
class AveragingMethod; class AveragingMethod;
/*---------------------------------------------------------------------------*\ /*---------------------------------------------------------------------------*\