src/OpenFOAM/fields/FieldFields/FieldField/FieldFieldReuseFunctions.H

   1 /*---------------------------------------------------------------------------*\
   2   =========                 |
   3   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
   4    \\    /   O peration     |
   5     \\  /    A nd           | Copyright (C) 1991-2009 OpenCFD Ltd.
   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 \*---------------------------------------------------------------------------*/
  26
  27 #ifndef FieldFieldReuseFunctions_H
  28 #define FieldFieldReuseFunctions_H
  29
  30 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
  31
  32 namespace Foam
  33 {
  34
  35 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
  36
  37 template<template<class> class Field, class TypeR, class Type1>
  38 class reuseTmpFieldField
  39 {
  40 public:
  41
  42     static tmp<FieldField<Field, TypeR> > New
  43     (
  44         const tmp<FieldField<Field, Type1> >& tf1
  45     )
  46     {
  47         return tmp<FieldField<Field, TypeR> >
  48         (
  49             FieldField<Field, TypeR>::NewCalculatedType(tf1())
  50         );
  51     }
  52
  53     static void clear(const tmp<FieldField<Field, Type1> >& tf1)
  54     {
  55         tf1.clear();
  56     }
  57 };
  58
  59
  60 template<template<class> class Field, class TypeR>
  61 class reuseTmpFieldField<Field, TypeR, TypeR>
  62 {
  63 public:
  64
  65     static tmp<FieldField<Field, TypeR> > New
  66     (
  67         const tmp<FieldField<Field, TypeR> >& tf1
  68     )
  69     {
  70         if (tf1.isTmp())
  71         {
  72             return tf1;
  73         }
  74         else
  75         {
  76             return tmp<FieldField<Field, TypeR> >
  77             (
  78                 FieldField<Field, TypeR>::NewCalculatedType(tf1())
  79             );
  80         }
  81     }
  82
  83     static void clear(const tmp<FieldField<Field, TypeR> >& tf1)
  84     {
  85         if (tf1.isTmp())
  86         {
  87             tf1.ptr();
  88         }
  89     }
  90 };
  91
  92
  93 template
  94 <
  95     template<class> class Field,
  96     class TypeR,
  97     class Type1,
  98     class Type12,
  99     class Type2
 100 >
 101 class reuseTmpTmpFieldField
 102 {
 103 public:
 104
 105     static tmp<FieldField<Field, TypeR> > New
 106     (
 107         const tmp<FieldField<Field, Type1> >& tf1,
 108         const tmp<FieldField<Field, Type2> >& tf2
 109     )
 110     {
 111         return tmp<FieldField<Field, TypeR> >
 112         (
 113             FieldField<Field, TypeR>::NewCalculatedType(tf1())
 114         );
 115     }
 116
 117     static void clear
 118     (
 119         const tmp<FieldField<Field, Type1> >& tf1,
 120         const tmp<FieldField<Field, Type2> >& tf2
 121     )
 122     {
 123         tf1.clear();
 124         tf2.clear();
 125     }
 126 };
 127
 128
 129 template<template<class> class Field, class TypeR, class Type1, class Type12>
 130 class reuseTmpTmpFieldField<Field, TypeR, Type1, Type12, TypeR>
 131 {
 132 public:
 133
 134     static tmp<FieldField<Field, TypeR> > New
 135     (
 136         const tmp<FieldField<Field, Type1> >& tf1,
 137         const tmp<FieldField<Field, TypeR> >& tf2
 138     )
 139     {
 140         if (tf2.isTmp())
 141         {
 142             return tf2;
 143         }
 144         else
 145         {
 146             return tmp<FieldField<Field, TypeR> >
 147             (
 148                 FieldField<Field, TypeR>::NewCalculatedType(tf1())
 149             );
 150         }
 151     }
 152
 153     static void clear
 154     (
 155         const tmp<FieldField<Field, Type1> >& tf1,
 156         const tmp<FieldField<Field, TypeR> >& tf2
 157     )
 158     {
 159         tf1.clear();
 160         if (tf2.isTmp())
 161         {
 162             tf2.ptr();
 163         }
 164     }
 165 };
 166
 167
 168 template<template<class> class Field, class TypeR, class Type2>
 169 class reuseTmpTmpFieldField<Field, TypeR, TypeR, TypeR, Type2>
 170 {
 171 public:
 172
 173     static tmp<FieldField<Field, TypeR> > New
 174     (
 175         const tmp<FieldField<Field, TypeR> >& tf1,
 176         const tmp<FieldField<Field, Type2> >& tf2
 177     )
 178     {
 179         if (tf1.isTmp())
 180         {
 181             return tf1;
 182         }
 183         else
 184         {
 185             return tmp<FieldField<Field, TypeR> >
 186             (
 187                 FieldField<Field, TypeR>::NewCalculatedType(tf1())
 188             );
 189         }
 190     }
 191
 192     static void clear
 193     (
 194         const tmp<FieldField<Field, TypeR> >& tf1,
 195         const tmp<FieldField<Field, Type2> >& tf2
 196     )
 197     {
 198         if (tf1.isTmp())
 199         {
 200             tf1.ptr();
 201         }
 202         tf2.clear();
 203     }
 204 };
 205
 206
 207 template<template<class> class Field, class TypeR>
 208 class reuseTmpTmpFieldField<Field, TypeR, TypeR, TypeR, TypeR>
 209 {
 210 public:
 211
 212     static tmp<FieldField<Field, TypeR> > New
 213     (
 214         const tmp<FieldField<Field, TypeR> >& tf1,
 215         const tmp<FieldField<Field, TypeR> >& tf2
 216     )
 217     {
 218         if (tf1.isTmp())
 219         {
 220             return tf1;
 221         }
 222         else if (tf2.isTmp())
 223         {
 224             return tf2;
 225         }
 226         else
 227         {
 228             return tmp<FieldField<Field, TypeR> >
 229             (
 230                 FieldField<Field, TypeR>::NewCalculatedType(tf1())
 231             );
 232         }
 233     }
 234
 235     static void clear
 236     (
 237         const tmp<FieldField<Field, TypeR> >& tf1,
 238         const tmp<FieldField<Field, TypeR> >& tf2
 239     )
 240     {
 241         if (tf1.isTmp())
 242         {
 243             tf1.ptr();
 244             tf2.clear();
 245         }
 246         else if (tf2.isTmp())
 247         {
 248             tf1.clear();
 249             tf2.ptr();
 250         }
 251     }
 252 };
 253
 254
 255 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 256
 257 } // End namespace Foam
 258
 259 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 260
 261 #endif
 262
 263 // ************************************************************************* //