src/OpenFOAM/db/memberFunctionSelection/memberFunctionSelectionTables.H

   1 /*---------------------------------------------------------------------------*\
   2   =========                 |
   3   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
   4    \\    /   O peration     |
   5     \\  /    A nd           | Copyright held by original author
   6      \\/     M anipulation  |
   7 -------------------------------------------------------------------------------
   8 License
   9     This file is part of OpenFOAM.
  10
  11     OpenFOAM is free software; you can redistribute it and/or modify it
  12     under the terms of the GNU General Public License as published by the
  13     Free Software Foundation; either version 2 of the License, or (at your
  14     option) any later version.
  15
  16     OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
  17     ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  18     FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  19     for more details.
  20
  21     You should have received a copy of the GNU General Public License
  22     along with OpenFOAM; if not, write to the Free Software Foundation,
  23     Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
  24
  25 Class
  26     Foam::memberFunctionSelectionTables
  27
  28 Description
  29     Macros to enable the easy declaration of member function selection tables.
  30
  31 \*---------------------------------------------------------------------------*/
  32
  33 #include "token.H"
  34
  35 #ifndef memberFunctionSelectionTables_H
  36 #define memberFunctionSelectionTables_H
  37
  38 #include "HashTable.H"
  39
  40 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
  41
  42
  43 // external use:
  44 // ~~~~~~~~~~~~~
  45 // declare a run-time selection:
  46 #define declareMemberFunctionSelectionTable\
  47 (returnType,baseType,memberFunction,argNames,argList,parList)                 \
  48                                                                               \
  49     /* Construct from argList function pointer type */                        \
  50     typedef returnType (*memberFunction##argNames##MemberFunctionPtr)argList; \
  51                                                                               \
  52     /* Construct from argList function table type */                          \
  53     typedef HashTable                                                         \
  54         <memberFunction##argNames##MemberFunctionPtr, word, string::hash>     \
  55         memberFunction##argNames##MemberFunctionTable;                        \
  56                                                                               \
  57     /* Construct from argList function pointer table pointer */               \
  58     static memberFunction##argNames##MemberFunctionTable*                     \
  59         memberFunction##argNames##MemberFunctionTablePtr_;                    \
  60                                                                               \
  61     /* Class to add constructor from argList to table */                      \
  62     template<class baseType##Type>                                            \
  63     class add##memberFunction##argNames##MemberFunctionToTable                \
  64     {                                                                         \
  65     public:                                                                   \
  66                                                                               \
  67         add##memberFunction##argNames##MemberFunctionToTable                  \
  68         (                                                                     \
  69             const word& lookup = baseType##Type::typeName                     \
  70         )                                                                     \
  71         {                                                                     \
  72             construct##memberFunction##argNames##MemberFunctionTables();      \
  73             memberFunction##argNames##MemberFunctionTablePtr_->insert         \
  74             (                                                                 \
  75                 lookup,                                                       \
  76                 baseType##Type::memberFunction                                \
  77             );                                                                \
  78         }                                                                     \
  79                                                                               \
  80         ~add##memberFunction##argNames##MemberFunctionToTable()               \
  81         {                                                                     \
  82             destroy##memberFunction##argNames##MemberFunctionTables();        \
  83         }                                                                     \
  84     };                                                                        \
  85                                                                               \
  86     /* Table memberFunction called from the table add function */             \
  87     static void construct##memberFunction##argNames##MemberFunctionTables();  \
  88                                                                               \
  89     /* Table destructor called from the table add function destructor */      \
  90     static void destroy##memberFunction##argNames##MemberFunctionTables()
  91
  92
  93 // internal use:
  94 // constructor aid
  95 #define defineMemberFunctionSelectionTableMemberFunction\
  96 (baseType,memberFunction,argNames)                                            \
  97                                                                               \
  98     /* Table memberFunction called from the table add function */             \
  99     void baseType::construct##memberFunction##argNames##MemberFunctionTables()\
 100     {                                                                         \
 101         static bool constructed = false;                                      \
 102                                                                               \
 103         if (!constructed)                                                     \
 104         {                                                                     \
 105             baseType::memberFunction##argNames##MemberFunctionTablePtr_       \
 106                 = new baseType::memberFunction##argNames##MemberFunctionTable;\
 107                                                                               \
 108             constructed = true;                                               \
 109         }                                                                     \
 110     }
 111
 112
 113 // internal use:
 114 // destructor aid
 115 #define defineMemberFunctionSelectionTableDestructor\
 116 (baseType,memberFunction,argNames)                                            \
 117                                                                               \
 118     /* Table destructor called from the table add function destructor */      \
 119     void baseType::destroy##memberFunction##argNames##MemberFunctionTables()  \
 120     {                                                                         \
 121         if (baseType::memberFunction##argNames##MemberFunctionTablePtr_)      \
 122         {                                                                     \
 123             delete baseType::memberFunction##argNames##MemberFunctionTablePtr_;\
 124             baseType::memberFunction##argNames##MemberFunctionTablePtr_ = NULL;\
 125         }                                                                     \
 126     }
 127
 128
 129 // internal use:
 130 // create pointer to hash-table of functions
 131 #define defineMemberFunctionSelectionTablePtr\
 132 (baseType,memberFunction,argNames)                                            \
 133                                                                               \
 134     /* Define the memberFunction table */                                     \
 135     baseType::memberFunction##argNames##MemberFunctionTable*                  \
 136         baseType::memberFunction##argNames##MemberFunctionTablePtr_ = NULL
 137
 138
 139 // not much in use:
 140 #define defineTemplateMemberFunctionSelectionTablePtr\
 141 (baseType,memberFunction,argNames)                                            \
 142                                                                               \
 143     /* Define the memberFunction table */                                     \
 144     typename baseType::memberFunction##argNames##MemberFunctionTable*         \
 145         baseType::memberFunction##argNames##MemberFunctionTablePtr_ = NULL
 146
 147
 148 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 149
 150 // external use:
 151 // ~~~~~~~~~~~~~
 152 // define run-time selection table
 153 #define defineMemberFunctionSelectionTable\
 154 (baseType,memberFunction,argNames)                                            \
 155                                                                               \
 156     defineMemberFunctionSelectionTablePtr                                     \
 157         (baseType,memberFunction,argNames);                                   \
 158     defineMemberFunctionSelectionTableMemberFunction                          \
 159         (baseType,memberFunction,argNames)                                    \
 160     defineMemberFunctionSelectionTableDestructor                              \
 161         (baseType,memberFunction,argNames)
 162
 163
 164 // external use:
 165 // ~~~~~~~~~~~~~
 166 // define run-time selection table for template classes
 167 // use when baseType doesn't need a template argument (eg, is a typedef)
 168 #define defineTemplateMemberFunctionSelectionTable\
 169 (baseType,memberFunction,argNames)                                            \
 170                                                                               \
 171     template<>                                                                \
 172     defineMemberFunctionSelectionTablePtr                                     \
 173         (baseType,memberFunction,argNames);                                   \
 174     template<>                                                                \
 175     defineMemberFunctionSelectionTableMemberFunction                          \
 176         (baseType,memberFunction,argNames)                                    \
 177     template<>                                                                \
 178     defineMemberFunctionSelectionTableDestructor                              \
 179         (baseType,memberFunction,argNames)
 180
 181
 182 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 183
 184 // internal use:
 185 // constructor aid
 186 // use when baseType requires the Targ template argument
 187 #define defineTemplatedMemberFunctionSelectionTableMemberFunction\
 188 (baseType,memberFunction,argNames,Targ)                                       \
 189                                                                               \
 190     /* Table memberFunction called from the table add function */             \
 191     void baseType<Targ>::construct##memberFunction##argNames##MemberFunctionTables()\
 192     {                                                                         \
 193         static bool constructed = false;                                      \
 194                                                                               \
 195         if (!constructed)                                                     \
 196         {                                                                     \
 197             baseType<Targ>::memberFunction##argNames##MemberFunctionTablePtr_       \
 198                 = new baseType<Targ>::memberFunction##argNames##MemberFunctionTable;\
 199                                                                               \
 200             constructed = true;                                               \
 201         }                                                                     \
 202     }
 203
 204
 205 // internal use:
 206 // destructor aid
 207 // use when baseType requires the Targ template argument
 208 #define defineTemplatedMemberFunctionSelectionTableDestructor\
 209 (baseType,memberFunction,argNames,Targ)                                       \
 210                                                                               \
 211     /* Table destructor called from the table add function destructor */      \
 212     void baseType<Targ>::destroy##memberFunction##argNames##MemberFunctionTables()  \
 213     {                                                                         \
 214         if (baseType<Targ>::memberFunction##argNames##MemberFunctionTablePtr_)      \
 215         {                                                                     \
 216             delete baseType<Targ>::memberFunction##argNames##MemberFunctionTablePtr_;\
 217             baseType<Targ>::memberFunction##argNames##MemberFunctionTablePtr_ = NULL;\
 218         }                                                                     \
 219     }
 220
 221
 222 // internal use:
 223 // create pointer to hash-table of functions
 224 // use when baseType requires the Targ template argument
 225 #define defineTemplatedMemberFunctionSelectionTablePtr\
 226 (baseType,memberFunction,argNames,Targ)                                       \
 227                                                                               \
 228     /* Define the memberFunction table */                                     \
 229     baseType<Targ>::memberFunction##argNames##MemberFunctionTable*            \
 230         baseType<Targ>::memberFunction##argNames##MemberFunctionTablePtr_ = NULL
 231
 232
 233 // external use:
 234 // ~~~~~~~~~~~~~
 235 // define run-time selection table for template classes
 236 // use when baseType requires the Targ template argument
 237 #define defineTemplatedMemberFunctionSelectionTable\
 238 (baseType,memberFunction,argNames,Targ)                                       \
 239                                                                               \
 240     template<>                                                                \
 241     defineTemplatedMemberFunctionSelectionTablePtr                            \
 242         (baseType,memberFunction,argNames,Targ);                              \
 243     template<>                                                                \
 244     defineTemplatedMemberFunctionSelectionTableMemberFunction                 \
 245         (baseType,memberFunction,argNames,Targ)                               \
 246     template<>                                                                \
 247     defineTemplatedMemberFunctionSelectionTableDestructor                     \
 248         (baseType,memberFunction,argNames,Targ)
 249
 250 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 251
 252 #endif
 253
 254 // ************************************************************************* //