src/OpenFOAM/containers/Lists/UIndirectList/UIndirectListIO.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 "UIndirectList.H"
  27 #include "Ostream.H"
  28 #include "token.H"
  29 #include "contiguous.H"
  30
  31 // * * * * * * * * * * * * * * * Ostream Operator *  * * * * * * * * * * * * //
  32
  33 template<class T>
  34 Foam::Ostream& Foam::operator<<
  35 (
  36     Foam::Ostream& os,
  37     const Foam::UIndirectList<T>& L
  38 )
  39 {
  40     // Write list contents depending on data format
  41     if (os.format() == IOstream::ASCII || !contiguous<T>())
  42     {
  43         bool uniform = false;
  44
  45         if (L.size() > 1 && contiguous<T>())
  46         {
  47             uniform = true;
  48
  49             forAll(L, i)
  50             {
  51                 if (L[i] != L[0])
  52                 {
  53                     uniform = false;
  54                     break;
  55                 }
  56             }
  57         }
  58
  59         if (uniform)
  60         {
  61             // Write size and start delimiter
  62             os << L.size() << token::BEGIN_BLOCK;
  63
  64             // Write contents
  65             os << L[0];
  66
  67             // Write end delimiter
  68             os << token::END_BLOCK;
  69         }
  70         else if (L.size() < 11 && contiguous<T>())
  71         {
  72             // Write size and start delimiter
  73             os << L.size() << token::BEGIN_LIST;
  74
  75             // Write contents
  76             forAll(L, i)
  77             {
  78                 if (i) os << token::SPACE;
  79                 os << L[i];
  80             }
  81
  82             // Write end delimiter
  83             os << token::END_LIST;
  84         }
  85         else
  86         {
  87             // Write size and start delimiter
  88             os << nl << L.size() << nl << token::BEGIN_LIST;
  89
  90             // Write contents
  91             forAll(L, i)
  92             {
  93                 os << nl << L[i];
  94             }
  95
  96             // Write end delimiter
  97             os << nl << token::END_LIST << nl;
  98         }
  99     }
 100     else
 101     {
 102         // this is annoying, and wasteful, but there's currently no alternative
 103
 104         os << nl << L.size() << nl;
 105
 106         if (L.size())
 107         {
 108             List<T> lst = L();
 109
 110             os.write
 111             (
 112                 reinterpret_cast<const char*>(lst.cdata()),
 113                 lst.byteSize()
 114             );
 115         }
 116     }
 117
 118     // Check state of IOstream
 119     os.check("Ostream& operator<<(Ostream&, const UIndirectList&)");
 120
 121     return os;
 122 }
 123
 124
 125 // ************************************************************************* //