bool Foam::fileFormats::OFSsurfaceFormat<Face>::read
(
Istream& is,
MeshedSurface<Face>& surf
)
{
surf.clear();
if (!is.good())
{
FatalErrorIn
(
"fileFormats::OFSsurfaceFormat::read"
"(Istream&, MeshedSurface<Face>&)"
)
<< "read error "
<< exit(FatalError);
}
pointField pointLst;
List<Face> faceLst;
List<surfZone> zoneLst;
read(is, pointLst, faceLst, zoneLst);
surf.reset
(
xferMove(pointLst),
xferMove(faceLst),
xferMove(zoneLst)
);
return true;
}
bool Foam::fileFormats::OFSsurfaceFormat<Face>::read
(
Istream& is,
pointField& pointLst,
List<Face>& faceLst,
List<surfZone>& zoneLst
)
{
if (!is.good())
{
FatalErrorIn
(
"fileFormats::OFSsurfaceFormat::read"
"(Istream&, pointField&, List<Face>&, List<surfZone>&)"
)
<< "read error "
<< exit(FatalError);
}
// read surfZones:
is >> zoneLst;
// read points:
is >> pointLst;
// must triangulate?
if (MeshedSurface<Face>::isTri())
{
// read faces as 'face' and transcribe to 'triFace'
List<face> origFaces(is);
MeshedSurface<face> origSurf
(
xferMove(pointLst),
xferMove(origFaces),
xferMove(zoneLst)
);
MeshedSurface<Face> surf;
surf.transcribe(origSurf);
}
else
{
// read faces directly
is >> faceLst;
}
return true;
}
Foam::scalarRanges::scalarRanges(Istream& is)
:
List<scalarRange>(0)
{
DynamicList<scalarRange> lst;
while (is.good())
{
scalarRange sr(is);
if (sr.isDefined())
{
lst.append(sr);
}
}
transfer(lst);
}
bool Foam::IOobject::readHeader(Istream& is)
{
if (IOobject::debug)
{
Info<< "IOobject::readHeader(Istream&) : reading header for file "
<< is.name() << endl;
}
// Check Istream not already bad
if (!is.good())
{
if (rOpt_ == MUST_READ || rOpt_ == MUST_READ_IF_MODIFIED)
{
FatalIOErrorIn("IOobject::readHeader(Istream&)", is)
<< " stream not open for reading essential object from file "
<< is.name()
<< exit(FatalIOError);
}
if (IOobject::debug)
{
SeriousIOErrorIn("IOobject::readHeader(Istream&)", is)
<< " stream not open for reading from file "
<< is.name() << endl;
}
return false;
}
token firstToken(is);
if
(
is.good()
&& firstToken.isWord()
&& firstToken.wordToken() == "FoamFile"
)
{
dictionary headerDict(is);
is.version(headerDict.lookup("version"));
is.format(headerDict.lookup("format"));
headerClassName_ = word(headerDict.lookup("class"));
const word headerObject(headerDict.lookup("object"));
if (IOobject::debug && headerObject != name())
{
IOWarningIn("IOobject::readHeader(Istream&)", is)
<< " object renamed from "
<< name() << " to " << headerObject
<< " for file " << is.name() << endl;
}
// The note entry is optional
headerDict.readIfPresent("note", note_);
}
else
{
SeriousIOErrorIn("IOobject::readHeader(Istream&)", is)
<< "First token could not be read or is not the keyword 'FoamFile'"
<< nl << nl << "Check header is of the form:" << nl << endl;
writeHeader(Info);
return false;
}
// Check stream is still OK
if (is.good())
{
objState_ = GOOD;
}
else
{
if (rOpt_ == MUST_READ || rOpt_ == MUST_READ_IF_MODIFIED)
{
FatalIOErrorIn("IOobject::readHeader(Istream&)", is)
<< " stream failure while reading header"
<< " on line " << is.lineNumber()
<< " of file " << is.name()
<< " for essential object" << name()
<< exit(FatalIOError);
}
if (IOobject::debug)
{
Info<< "IOobject::readHeader(Istream&) :"
<< " stream failure while reading header"
<< " on line " << is.lineNumber()
<< " of file " << is.name() << endl;
}
objState_ = BAD;
return false;
}
if (IOobject::debug)
{
Info<< " .... read" << endl;
}
return true;
}
void test_ok (const charT*, const Traits*,
const char *cname, const char *tname)
{
typedef std::basic_istream<charT, Traits> Istream;
typedef typename Istream::sentry Sentry;
memfun_info (__LINE__, cname, tname, "operator bool () const");
const charT cbuf[] = { 'a', 'b', 'c', 'd', 'e', ' ', 'f', '\0' };
const std::ios_base::iostate states[] = {
std::ios_base::badbit,
std::ios_base::eofbit,
std::ios_base::failbit,
std::ios_base::goodbit,
std::ios_base::badbit | std::ios_base::eofbit,
std::ios_base::badbit | std::ios_base::failbit,
std::ios_base::eofbit | std::ios_base::failbit,
std::ios_base::badbit | std::ios_base::eofbit | std::ios_base::failbit
};
//////////////////////////////////////////////////////////////
// exercise 27.6.1.1.2, p5:
// - is.good() is true
// - noskipws is zero
// - is.flags() & ios_base::skipws
// - the function extracts and discards each character as long
// as the next available input character c is a whitespace
// character
// = if, after any preparation is completed, is.good() is true,
// ok_ != false otherwise, ok_ == false.
unsigned iter = 0; // iteration counter
for (unsigned i = 0; i != sizeof states / sizeof *states; ++i) {
for (unsigned j = 0; j != 2; ++j /* noskipws */) {
for (unsigned k = 0; k != 2; ++k /* ios_base::skipws */) {
for (charT wc = charT ('a'); wc != charT ('c'); ++wc) {
const Ctype<charT> ctp (1, wc);
Streambuf<charT, Traits>
sb (cbuf, cbuf + sizeof cbuf / sizeof *cbuf);
Istream is (&sb);
is.setstate (states [i]);
if (k)
is.setf (std::ios_base::skipws);
else
is.unsetf (std::ios_base::skipws);
const std::locale loc =
is.imbue (std::locale (is.getloc (), &ctp));
// imbue the previous locale into the stream
// buffer to verify that the sentry ctor uses
// the locale imbued in the stream object and
// not the one in the stream buffer
sb.pubimbue (loc);
const Sentry guard (is, 0 != j);
_RWSTD_UNUSED (guard);
const bool success =
is.good () && guard
|| !is.good () && !guard;
rw_assert (success, 0, __LINE__,
"%u. %{$SENTRY}"
"(%{$ISTREAM} &is, bool noskipws "
"= %d).operator bool() == %d; initial "
"is.state() = %{Is}, is.flags() & "
"ios::skipws = %d",
iter, j, is.good (),
states [i], k);
++iter;
}
}
}
}
}
void test_ctor (const charT*, const Traits*,
const char *cname, const char *tname)
{
typedef std::basic_istream<charT, Traits> Istream;
typedef typename Istream::sentry Sentry;
memfun_info (__LINE__, cname, tname, "sentry (%{$ISTREAM}&, bool)");
const charT cbuf[] = { 'a', 'b', 'c', 'd', 'e', ' ', 'f', '\0' };
const std::ios_base::iostate states[] = {
std::ios_base::badbit,
std::ios_base::eofbit,
std::ios_base::failbit,
std::ios_base::goodbit,
std::ios_base::badbit | std::ios_base::eofbit,
std::ios_base::badbit | std::ios_base::failbit,
std::ios_base::eofbit | std::ios_base::failbit,
std::ios_base::badbit | std::ios_base::eofbit | std::ios_base::failbit
};
//////////////////////////////////////////////////////////////
// exercise 27.6.1.1.2, p1:
// - is.good() is true
// - is.tie() is not null
// = the function calls is.tie().flush()
unsigned iter = 0; // iteration counter
for (unsigned i = 0; i != sizeof states / sizeof *states; ++i) {
for (unsigned j = 0; j != 2; ++j /* noskipws */) {
Streambuf<charT, Traits>
sb (cbuf, cbuf + sizeof cbuf / sizeof *cbuf);
Istream is (&sb);
// flush() is called iff
// all of the following conditions hold
const bool flush_called = is.good () && 0 != is.tie ();
const Sentry guard (is, 0 != j);
_RWSTD_UNUSED (guard);
rw_assert (flush_called == sb.nsyncs_, 0, __LINE__,
"%u. basic_istream<%s, %s>::sentry::sentry"
"(basic_istream &is, bool noskipws = %d); "
"expected to call is.flush () %d times, got %d"
"initial is.state () = %{Is}, is.flags() & "
"ios::skipws = %d",
iter, cname, tname, 0 != j, flush_called, sb.nsyncs_,
states [i], is.flags () & std::ios_base::skipws);
++iter;
}
}
//////////////////////////////////////////////////////////////
// exercise 27.6.1.1.2, p1:
// - is.good() is true
// - noskipws is zero
// - is.flags() & ios_base::skipws
// = the function extracts and discards each character as long
// as the next available input character c is a whitespace
// character.
for (unsigned i = 0; i != sizeof states / sizeof *states; ++i) {
for (unsigned j = 0; j != 2; ++j /* noskipws */) {
for (unsigned k = 0; k != 2; ++k /* ios_base::skipws */) {
for (charT wc = charT ('a'); wc != charT ('c'); ++wc) {
const Ctype<charT> ctp (1, wc);
Streambuf<charT, Traits>
sb (cbuf, cbuf + sizeof cbuf / sizeof *cbuf);
Istream is (&sb);
is.setstate (states [i]);
if (k)
is.setf (std::ios_base::skipws);
else
is.unsetf (std::ios_base::skipws);
const std::locale loc =
is.imbue (std::locale (is.getloc (), &ctp));
// imbue the previous locale into the stream
// buffer to verify that the sentry ctor uses
// the locale imbued in the stream object and
// not the one in the stream buffer
sb.pubimbue (loc);
// a whitespace character is extracted iff
// all of the following conditions hold
const bool extract =
is.good ()
&& 0 == j
&& is.flags () & std::ios_base::skipws
&& cbuf [0] == wc;
const Sentry guard (is, 0 != j);
_RWSTD_UNUSED (guard);
rw_assert (cbuf + extract == sb.pubgptr (), 0, __LINE__,
"%u. %{$SENTRY}::sentry"
"(%{$ISTREAM} &is, bool noskipws "
"= %b); expected to extract %d "
"whitespace chars ('%c') from %{*Ac}, "
"extracted %u; initial is.state () = "
"%{Is}, is.flags() & ios::skipws = %d",
iter, j, extract + 0, char (wc),
int (sizeof (*cbuf)), cbuf,
sb.pubgptr () - sb.pubeback (),
states [i], k);
// verify that the ctor doesn't affect gcount()
rw_assert (0 == is.gcount (), 0, __LINE__,
"%u. %{$SENTRY}::sentry"
"(%{$ISTREAM} &is = %{*Ac}, bool noskipws "
"= %b); changed is.gcount() from 0 to %i",
iter, int (sizeof (*cbuf)), cbuf, j,
is.gcount ());
++iter;
}
}
}
}
}
void test_readsome (const charT *cbuf, const Traits*,
unsigned cbuf_size,
unsigned i, // index into states
unsigned j, // number of chars to read
unsigned k, // when underflow() will fail
int l, // value returned from showmanyc()
unsigned m) // how underflow should fail()
{
typedef std::basic_istream<charT, Traits> Istream;
static unsigned iter = 0; // iteration counter
// construct a stream buffer object and initialize its read
// sequence with the character buffer
Streambuf<charT, Traits> sb (cbuf, cbuf + cbuf_size - 1);
sb.showmanyc_ = l;
const char* err_type = 0;
if (m < 1) {
// have the stream buffer object's underflow() fail (by
// throwing an exception if possible) after k characters
// have been extracted (this object calls underflow() for
// every char)
sb.throw_after_ = k;
err_type = "threw";
}
else {
// have the stream buffer object's underflow() fail by
// returning eof after k characters have been extracted
// (this object calls underflow() for every char)
sb.fail_after_ = k;
err_type = "returned EOF";
}
// construct an istream object and initialize it with the user
// defined streambuf object
Istream is (&sb);
// set the stream object's initial state
is.setstate (states [i]);
// the number of extracted whitespace characters expected to
// be reported by gcount() must equal the number of successful
// extractions computed by the the stream buffer overridden
// underflow member function
const int extract =
is.good () ? j < k ? int (j) < l ? j
: l < 0 ? 0 : l
: int (k) < l ? k
: l < 0 ? 0 : l
: 0;
charT buf [256] = { 0 };
std::streamsize nread = -1;
// format the FCALL environment variable so that it can be
// conveniently used in diagnostics below
rw_fprintf (0, "%u. %{$FCALL!:@}",
iter,
"%{$ISTREAM}(%{*Ac}).readsome(%p, %d)",
int (sizeof *cbuf), cbuf, buf, j);
#ifndef _RWSTD_NO_EXCEPTIONS
const char *caught = 0;
// on every other iteration set badbit in exceptions to check
// that the thrown object is propagated by the function
if (k % 2 && !is.bad ())
is.exceptions (std::ios_base::badbit);
try {
nread = is.readsome (buf, j);
}
catch (const char *s) {
caught = s;
}
catch (...) {
caught = "...";
rw_assert (0, 0, __LINE__,
"%{$FCALL} threw an exception of unexpected type");
}
//////////////////////////////////////////////////////////////////
// verify that the function propagates exceptions thrown from the
// streambuf object only when badbit is set in the stream object's
// exceptions()
rw_assert (!caught || (k % 2), 0, __LINE__,
"%{$FCALL} unexpectedly propagated an exception");
#else // if defined (_RWSTD_NO_EXCEPTIONS)
nread = is.readsome (buf, j);
#endif // _RWSTD_NO_EXCEPTIONS
//////////////////////////////////////////////////////////////////
// verify that the function returned the expected number of
// extracted characters
const std::streamsize extracted = sb.pubgptr () - sb.pubeback ();
rw_assert (extract == extracted, 0, __LINE__,
"%{$FCALL} expected to extract %d chars, got %u; "
"initial state = %{Is}, underflow %s at extraction %u",
extract, extracted, states [i],
err_type, k);
//////////////////////////////////////////////////////////////////
// verify that the expected number of characters have been
// extracted from the stream
rw_assert (cbuf + extract == sb.pubgptr (), 0, __LINE__,
"%{$FCALL} expected to extract %d chars, got %u; "
"initial state = %{Is}, underflow %s at extraction %u",
extract, extracted, states [i],
err_type, k);
//////////////////////////////////////////////////////////////////
// verify that the extracted characters match those in the buffer
rw_assert (0 == std::char_traits<charT>::compare (buf, cbuf, extract),
0, __LINE__,
"%{$FCALL} expected to extract the first %d chars, got %{*Ac}",
extract, int (sizeof *buf), buf);
//////////////////////////////////////////////////////////////////
// verify that gcount() correctly reflects the number of
// characters successfully extracted from the stream
rw_assert (extract == is.gcount (), 0, __LINE__,
"%{$FCALL}: gcount() == %d, got %d; initial state = %{Is}, "
"underflow %s at extraction %u",
extract, is.gcount (), states [i],
err_type, k);
//////////////////////////////////////////////////////////////////
// verify the state of the stream object after the function call
// expected stream state after the function call is unchanged
// (i.e., the initial stream state), except...
std::ios_base::iostate expect_state = states [i];
if (!states [i]) {
#ifndef _RWSTD_NO_EXCEPTIONS
// ...if an extraction is attempted, or even if the first
// character on the stream is peeked at, and an exception
// is thrown during input, badbit should be set, otherwise
// if in_avail() returned -1, eofbit should be set, else
// the state should be good
if (-2 == l)
expect_state = std::ios_base::badbit;
else if (l < 0)
expect_state = std::ios_base::eofbit;
else
expect_state = std::ios_base::goodbit;
#else // if defined (_RWSTD_NO_EXCEPTIONS)
if (l < 0)
expect_state = std::ios_base::eofbit;
else
expect_state = std::ios_base::goodbit;
#endif // _RWSTD_NO_EXCEPTIONS
}
else {
// ...if the initial stream state is not good, failbit
// must be set
expect_state = states [i] | std::ios_base::failbit;
}
rw_assert (is.rdstate () == expect_state, 0, __LINE__,
"%{$FCALL}: rdstate() == %{Is}, got %{Is}; "
"extracted %u characters; "
"initial state = %{Is}, underflow %s at extraction %u",
expect_state, is.rdstate (), extracted,
states [i], err_type, k);
++iter;
}
