src/OpenFOAM/db/IOobjects/CompactIOField/CompactIOField.C

   1 /*---------------------------------------------------------------------------*\
   2   =========                 |
   3   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
   4    \\    /   O peration     |
   5     \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
   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
  13     the Free Software Foundation, either version 3 of the License, or
  14     (at your 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, see <http://www.gnu.org/licenses/>.
  23
  24 \*---------------------------------------------------------------------------*/
  25
  26 #include "CompactIOField.H"
  27 #include "labelList.H"
  28
  29 // * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
  30
  31 template<class T, class BaseType>
  32 void Foam::CompactIOField<T, BaseType>::readFromStream()
  33 {
  34     Istream& is = readStream(word::null);
  35
  36     if (headerClassName() == IOField<T>::typeName)
  37     {
  38         is >> static_cast<Field<T>&>(*this);
  39         close();
  40     }
  41     else if (headerClassName() == typeName)
  42     {
  43         is >> *this;
  44         close();
  45     }
  46     else
  47     {
  48         FatalIOErrorIn
  49         (
  50             "CompactIOField<T, BaseType>::readFromStream()",
  51             is
  52         )   << "unexpected class name " << headerClassName()
  53             << " expected " << typeName << " or " << IOField<T>::typeName
  54             << endl
  55             << "    while reading object " << name()
  56             << exit(FatalIOError);
  57     }
  58 }
  59
  60
  61 // * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * * //
  62
  63 template<class T, class BaseType>
  64 Foam::CompactIOField<T, BaseType>::CompactIOField(const IOobject& io)
  65 :
  66     regIOobject(io)
  67 {
  68     if
  69     (
  70         io.readOpt() == IOobject::MUST_READ
  71      || (io.readOpt() == IOobject::READ_IF_PRESENT && headerOk())
  72     )
  73     {
  74         readFromStream();
  75     }
  76 }
  77
  78
  79 template<class T, class BaseType>
  80 Foam::CompactIOField<T, BaseType>::CompactIOField
  81 (
  82     const IOobject& io,
  83     const label size
  84 )
  85 :
  86     regIOobject(io)
  87 {
  88     if
  89     (
  90         io.readOpt() == IOobject::MUST_READ
  91      || (io.readOpt() == IOobject::READ_IF_PRESENT && headerOk())
  92     )
  93     {
  94         readFromStream();
  95     }
  96     else
  97     {
  98         Field<T>::setSize(size);
  99     }
 100 }
 101
 102
 103 template<class T, class BaseType>
 104 Foam::CompactIOField<T, BaseType>::CompactIOField
 105 (
 106     const IOobject& io,
 107     const Field<T>& list
 108 )
 109 :
 110     regIOobject(io)
 111 {
 112     if
 113     (
 114         io.readOpt() == IOobject::MUST_READ
 115      || (io.readOpt() == IOobject::READ_IF_PRESENT && headerOk())
 116     )
 117     {
 118         readFromStream();
 119     }
 120     else
 121     {
 122         Field<T>::operator=(list);
 123     }
 124 }
 125
 126
 127 template<class T, class BaseType>
 128 Foam::CompactIOField<T, BaseType>::CompactIOField
 129 (
 130     const IOobject& io,
 131     const Xfer<Field<T> >& list
 132 )
 133 :
 134     regIOobject(io)
 135 {
 136     Field<T>::transfer(list());
 137
 138     if
 139     (
 140         io.readOpt() == IOobject::MUST_READ
 141      || (io.readOpt() == IOobject::READ_IF_PRESENT && headerOk())
 142     )
 143     {
 144         readFromStream();
 145     }
 146 }
 147
 148
 149 // * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * * //
 150
 151 template<class T, class BaseType>
 152 Foam::CompactIOField<T, BaseType>::~CompactIOField()
 153 {}
 154
 155
 156
 157 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 158
 159 template<class T, class BaseType>
 160 bool Foam::CompactIOField<T, BaseType>::writeObject
 161 (
 162     IOstream::streamFormat fmt,
 163     IOstream::versionNumber ver,
 164     IOstream::compressionType cmp
 165 ) const
 166 {
 167     if (fmt == IOstream::ASCII)
 168     {
 169         // Change type to be non-compact format type
 170         const word oldTypeName = typeName;
 171
 172         const_cast<word&>(typeName) = IOField<T>::typeName;
 173
 174         bool good = regIOobject::writeObject(fmt, ver, cmp);
 175
 176         // Change type back
 177         const_cast<word&>(typeName) = oldTypeName;
 178
 179         return good;
 180     }
 181     else
 182     {
 183         return regIOobject::writeObject(fmt, ver, cmp);
 184     }
 185 }
 186
 187
 188 template<class T, class BaseType>
 189 bool Foam::CompactIOField<T, BaseType>::writeData(Ostream& os) const
 190 {
 191     return (os << *this).good();
 192 }
 193
 194
 195 // * * * * * * * * * * * * * * * Member Operators  * * * * * * * * * * * * * //
 196
 197 template<class T, class BaseType>
 198 void Foam::CompactIOField<T, BaseType>::operator=
 199 (
 200     const CompactIOField<T, BaseType>& rhs
 201 )
 202 {
 203     Field<T>::operator=(rhs);
 204 }
 205
 206
 207 template<class T, class BaseType>
 208 void Foam::CompactIOField<T, BaseType>::operator=(const Field<T>& rhs)
 209 {
 210     Field<T>::operator=(rhs);
 211 }
 212
 213
 214 // * * * * * * * * * * * * * * * Friend Operators  * * * * * * * * * * * * * //
 215
 216 template<class T, class BaseType>
 217 Foam::Istream& Foam::operator>>
 218 (
 219     Foam::Istream& is,
 220     Foam::CompactIOField<T, BaseType>& L
 221 )
 222 {
 223     // Read compact
 224     const labelList start(is);
 225     const Field<BaseType> elems(is);
 226
 227     // Convert
 228     L.setSize(start.size()-1);
 229
 230     forAll(L, i)
 231     {
 232         T& subField = L[i];
 233
 234         label index = start[i];
 235         subField.setSize(start[i+1] - index);
 236
 237         forAll(subField, j)
 238         {
 239             subField[j] = elems[index++];
 240         }
 241     }
 242
 243     return is;
 244 }
 245
 246
 247 template<class T, class BaseType>
 248 Foam::Ostream& Foam::operator<<
 249 (
 250     Foam::Ostream& os,
 251     const Foam::CompactIOField<T, BaseType>& L
 252 )
 253 {
 254     // Keep ascii writing same.
 255     if (os.format() == IOstream::ASCII)
 256     {
 257         os << static_cast<const Field<T>&>(L);
 258     }
 259     else
 260     {
 261         // Convert to compact format
 262         labelList start(L.size()+1);
 263
 264         start[0] = 0;
 265         for (label i = 1; i < start.size(); i++)
 266         {
 267             start[i] = start[i-1]+L[i-1].size();
 268         }
 269
 270         Field<BaseType> elems(start[start.size()-1]);
 271
 272         label elemI = 0;
 273         forAll(L, i)
 274         {
 275             const T& subField = L[i];
 276
 277             forAll(subField, j)
 278             {
 279                 elems[elemI++] = subField[j];
 280             }
 281         }
 282         os << start << elems;
 283     }
 284
 285     return os;
 286 }
 287
 288
 289 // ************************************************************************* //