src/OpenFOAM/db/IOstreams/Pstreams/UIPstream.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 "error.H"
  27 #include "UIPstream.H"
  28 #include "int.H"
  29 #include "token.H"
  30 #include <cctype>
  31
  32
  33 // * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
  34
  35 inline void Foam::UIPstream::checkEof()
  36 {
  37     if (externalBufPosition_ == messageSize_)
  38     {
  39         setEof();
  40     }
  41 }
  42
  43
  44 template<class T>
  45 inline void Foam::UIPstream::readFromBuffer(T& t)
  46 {
  47     const size_t align = sizeof(T);
  48     externalBufPosition_ = align + ((externalBufPosition_ - 1) & ~(align - 1));
  49
  50     t = reinterpret_cast<T&>(externalBuf_[externalBufPosition_]);
  51     externalBufPosition_ += sizeof(T);
  52     checkEof();
  53 }
  54
  55
  56 inline void Foam::UIPstream::readFromBuffer
  57 (
  58     void* data,
  59     size_t count,
  60     size_t align
  61 )
  62 {
  63     if (align > 1)
  64     {
  65         externalBufPosition_ =
  66             align
  67           + ((externalBufPosition_ - 1) & ~(align - 1));
  68     }
  69
  70     register const char* bufPtr = &externalBuf_[externalBufPosition_];
  71     register char* dataPtr = reinterpret_cast<char*>(data);
  72     register size_t i = count;
  73     while (i--) *dataPtr++ = *bufPtr++;
  74     externalBufPosition_ += count;
  75     checkEof();
  76 }
  77
  78
  79 // * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
  80
  81 Foam::UIPstream::~UIPstream()
  82 {
  83     if (clearAtEnd_ && eof())
  84     {
  85         if (debug)
  86         {
  87             Pout<< "UIPstream::~UIPstream() : clearing externalBuf_ of size "
  88                 << externalBuf_.size() << endl;
  89         }
  90         externalBuf_.clearStorage();
  91     }
  92 }
  93
  94 // * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * * //
  95
  96 Foam::Istream& Foam::UIPstream::read(token& t)
  97 {
  98     // Return the put back token if it exists
  99     if (Istream::getBack(t))
 100     {
 101         return *this;
 102     }
 103
 104     char c;
 105
 106     // return on error
 107     if (!read(c))
 108     {
 109         t.setBad();
 110         return *this;
 111     }
 112
 113     // Set the line number of this token to the current stream line number
 114     t.lineNumber() = lineNumber();
 115
 116     // Analyse input starting with this character.
 117     switch (c)
 118     {
 119         // Punctuation
 120         case token::END_STATEMENT :
 121         case token::BEGIN_LIST :
 122         case token::END_LIST :
 123         case token::BEGIN_SQR :
 124         case token::END_SQR :
 125         case token::BEGIN_BLOCK :
 126         case token::END_BLOCK :
 127         case token::COLON :
 128         case token::COMMA :
 129         case token::ASSIGN :
 130         case token::ADD :
 131         case token::SUBTRACT :
 132         case token::MULTIPLY :
 133         case token::DIVIDE :
 134         {
 135             t = token::punctuationToken(c);
 136             return *this;
 137         }
 138
 139         // Word
 140         case token::WORD :
 141         {
 142             word* pval = new word;
 143             if (read(*pval))
 144             {
 145                 if (token::compound::isCompound(*pval))
 146                 {
 147                     t = token::compound::New(*pval, *this).ptr();
 148                     delete pval;
 149                 }
 150                 else
 151                 {
 152                     t = pval;
 153                 }
 154             }
 155             else
 156             {
 157                 delete pval;
 158                 t.setBad();
 159             }
 160             return *this;
 161         }
 162
 163         // String
 164         case token::STRING :
 165         case token::VERBATIMSTRING :
 166         {
 167             string* pval = new string;
 168             if (read(*pval))
 169             {
 170                 t = pval;
 171                 if (c == token::VERBATIMSTRING)
 172                 {
 173                     t.type() = token::VERBATIMSTRING;
 174                 }
 175             }
 176             else
 177             {
 178                 delete pval;
 179                 t.setBad();
 180             }
 181             return *this;
 182         }
 183
 184         // Label
 185         case token::LABEL :
 186         {
 187             label val;
 188             if (read(val))
 189             {
 190                 t = val;
 191             }
 192             else
 193             {
 194                 t.setBad();
 195             }
 196             return *this;
 197         }
 198
 199         // floatScalar
 200         case token::FLOAT_SCALAR :
 201         {
 202             floatScalar val;
 203             if (read(val))
 204             {
 205                 t = val;
 206             }
 207             else
 208             {
 209                 t.setBad();
 210             }
 211             return *this;
 212         }
 213
 214         // doubleScalar
 215         case token::DOUBLE_SCALAR :
 216         {
 217             doubleScalar val;
 218             if (read(val))
 219             {
 220                 t = val;
 221             }
 222             else
 223             {
 224                 t.setBad();
 225             }
 226             return *this;
 227         }
 228
 229         // Character (returned as a single character word) or error
 230         default:
 231         {
 232             if (isalpha(c))
 233             {
 234                 t = word(c);
 235                 return *this;
 236             }
 237
 238             setBad();
 239             t.setBad();
 240
 241             return *this;
 242         }
 243     }
 244 }
 245
 246
 247 Foam::Istream& Foam::UIPstream::read(char& c)
 248 {
 249     c = externalBuf_[externalBufPosition_];
 250     externalBufPosition_++;
 251     checkEof();
 252     return *this;
 253 }
 254
 255
 256 Foam::Istream& Foam::UIPstream::read(word& str)
 257 {
 258     size_t len;
 259     readFromBuffer(len);
 260     str = &externalBuf_[externalBufPosition_];
 261     externalBufPosition_ += len + 1;
 262     checkEof();
 263     return *this;
 264 }
 265
 266
 267 Foam::Istream& Foam::UIPstream::read(string& str)
 268 {
 269     size_t len;
 270     readFromBuffer(len);
 271     str = &externalBuf_[externalBufPosition_];
 272     externalBufPosition_ += len + 1;
 273     checkEof();
 274     return *this;
 275 }
 276
 277
 278 Foam::Istream& Foam::UIPstream::read(label& val)
 279 {
 280     readFromBuffer(val);
 281     return *this;
 282 }
 283
 284
 285 Foam::Istream& Foam::UIPstream::read(floatScalar& val)
 286 {
 287     readFromBuffer(val);
 288     return *this;
 289 }
 290
 291
 292 Foam::Istream& Foam::UIPstream::read(doubleScalar& val)
 293 {
 294     readFromBuffer(val);
 295     return *this;
 296 }
 297
 298
 299 Foam::Istream& Foam::UIPstream::read(char* data, std::streamsize count)
 300 {
 301     if (format() != BINARY)
 302     {
 303         FatalErrorIn("UIPstream::read(char*, std::streamsize)")
 304             << "stream format not binary"
 305             << Foam::abort(FatalError);
 306     }
 307
 308     readFromBuffer(data, count, 8);
 309     return *this;
 310 }
 311
 312
 313 Foam::Istream& Foam::UIPstream::rewind()
 314 {
 315     externalBufPosition_ = 0;
 316     return *this;
 317 }
 318
 319
 320 void Foam::UIPstream::print(Ostream& os) const
 321 {
 322     os  << "Reading from processor " << fromProcNo_
 323         << " to processor " << myProcNo() << Foam::endl;
 324 }
 325
 326
 327 // ************************************************************************* //