Commit e45dc318 authored by Mark Olesen's avatar Mark Olesen
Browse files

UIndirectList output operator

- TODO: binary output is still a bit silly
parent 91b5739a
......@@ -28,6 +28,8 @@ Description
#include "UIndirectList.H"
#include "IOstreams.H"
#include "ListOps.H"
#include "OFstream.H"
using namespace Foam;
......@@ -52,29 +54,32 @@ int main(int argc, char *argv[])
UIndirectList<double> idl(completeList, addresses);
forAll(idl, i)
{
Info<< idl[i] << token::SPACE;
}
Info<< endl;
Info<< idl << "\n";
idl[1] = -666;
Info<< "idl[1] changed:" << idl() << endl;
Info<< "idl[1] changed:" << idl << endl;
idl = -999;
Info<< "idl changed:" << idl() << endl;
Info<< "idl changed:" << idl << endl;
UIndirectList<double> idl2(idl);
Info<< "idl2:" << idl2() << endl;
Info<< "idl2: " << idl2 << endl;
idl = idl2();
Info<< "idl assigned from UList:" << idl() << endl;
{
List<double> ident(idl.size());
forAll(ident, i)
{
ident[i] = ident.size() - i;
}
idl = ident;
}
Info<< "idl assigned from UList:" << idl << endl;
List<double> realList = UIndirectList<double>(completeList, addresses);
......
......@@ -26,8 +26,8 @@ Class
Foam::UIndirectList
Description
A List with indirect addressing. Like IndirectList but does not store
addressing.
A List with indirect addressing.
Like IndirectList but does not store addressing.
SourceFiles
UIndirectListI.H
......@@ -44,8 +44,12 @@ SourceFiles
namespace Foam
{
// Forward declaration of friend functions and operators
template<class T> class UIndirectList;
template<class T> Ostream& operator<<(Ostream&, const UIndirectList<T>&);
/*---------------------------------------------------------------------------*\
Class UIndirectList Declaration
Class UIndirectList Declaration
\*---------------------------------------------------------------------------*/
template<class T>
......@@ -92,6 +96,17 @@ public:
//- Assignment of all entries to the given value
inline void operator=(const T&);
// Ostream operator
//- Write UIndirectList to Ostream
// Binary output is currently still a bit of a problem
friend Ostream& operator<<
#ifndef __CINT__
<T>
#endif
(Ostream&, const UIndirectList<T>&);
};
......@@ -103,6 +118,10 @@ public:
#include "UIndirectListI.H"
#ifdef NoRepository
# include "UIndirectListIO.C"
#endif
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
......
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 1991-2009 OpenCFD Ltd.
\\/ M anipulation |
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
OpenFOAM is free software; you can redistribute it and/or modify it
under the terms of the GNU General Public License as published by the
Free Software Foundation; either version 2 of the License, or (at your
option) any later version.
OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
for more details.
You should have received a copy of the GNU General Public License
along with OpenFOAM; if not, write to the Free Software Foundation,
Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
\*---------------------------------------------------------------------------*/
#include "UIndirectList.H"
#include "Ostream.H"
#include "token.H"
#include "contiguous.H"
// * * * * * * * * * * * * * * * Ostream Operator * * * * * * * * * * * * * //
template<class T>
Foam::Ostream& Foam::operator<<
(
Foam::Ostream& os,
const Foam::UIndirectList<T>& L
)
{
// Write list contents depending on data format
if (os.format() == IOstream::ASCII || !contiguous<T>())
{
bool uniform = false;
if (L.size() > 1 && contiguous<T>())
{
uniform = true;
forAll(L, i)
{
if (L[i] != L[0])
{
uniform = false;
break;
}
}
}
if (uniform)
{
// Write size and start delimiter
os << L.size() << token::BEGIN_BLOCK;
// Write contents
os << L[0];
// Write end delimiter
os << token::END_BLOCK;
}
else if (L.size() < 11 && contiguous<T>())
{
// Write size and start delimiter
os << L.size() << token::BEGIN_LIST;
// Write contents
forAll(L, i)
{
if (i) os << token::SPACE;
os << L[i];
}
// Write end delimiter
os << token::END_LIST;
}
else
{
// Write size and start delimiter
os << nl << L.size() << nl << token::BEGIN_LIST;
// Write contents
forAll(L, i)
{
os << nl << L[i];
}
// Write end delimiter
os << nl << token::END_LIST << nl;
}
}
else
{
// this is annoying, and wasteful, but there's currently no alternative
os << nl << L.size() << nl;
if (L.size())
{
List<T> lst = L();
os.write
(
reinterpret_cast<const char*>(lst.cdata()),
lst.byteSize()
);
}
}
// Check state of IOstream
os.check("Ostream& operator<<(Ostream&, const UIndirectList&)");
return os;
}
// ************************************************************************* //
Markdown is supported
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment