daStreamIo.cpp

Go to the documentation of this file.

//------------------------------------------------------------------------------
//------------------------------------------------------------------------------

//----- Included files ---------------------------------------------------------

// 1. Precompiled header

// 2. My header
#include <xmscore/dataio/daStreamIo.h>

// 3. Standard Library Headers
#include <fstream>
#include <sstream>

// 4. External Library Headers
#include <boost/archive/iterators/base64_from_binary.hpp>
#include <boost/archive/iterators/binary_from_base64.hpp>
#include <boost/archive/iterators/transform_width.hpp>
#include <boost/unordered_map.hpp>
#include <zlib.h>

// 5. Shared Headers
#include <xmscore/misc/StringUtil.h>
#include <xmscore/misc/XmError.h>
#include <xmscore/misc/XmLog.h>

//----- Forward declarations ---------------------------------------------------

//----- External globals -------------------------------------------------------

//----- Namespace declaration --------------------------------------------------

namespace xms
{
//----- Constants / Enumerations -----------------------------------------------

//----- Classes / Structs ------------------------------------------------------

//----- Class / Function definitions -------------------------------------------

namespace
{
const int MAX_BLOCK_SIZE = 1024 * 32;
}

class DaStreamReader::Impl
{
public:
  Impl(std::istream& a_inStream, bool a_binaryArrays)
  : m_inStream(a_inStream)
  , m_binaryArrays(a_binaryArrays)
  {
  }

  std::istream& m_inStream; 
  bool m_binaryArrays;      
};

class DaStreamWriter::Impl
{
public:
  Impl(std::ostream& a_outStream, bool a_binaryArrays)
  : m_outStream(a_outStream)
  , m_binaryArrays(a_binaryArrays)
  {
  }

  std::ostream& m_outStream;        
  bool m_binaryArrays;              
  int m_blockSize = MAX_BLOCK_SIZE; 
};

namespace
{
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
int32_t iCompress(const char* a_source, int32_t a_sourceLength, char* a_dest, int32_t a_destLength)
{
  auto compressedLength = static_cast<uLong>(a_destLength);
  auto result = compress2(reinterpret_cast<Bytef*>(a_dest), &compressedLength,
                          reinterpret_cast<const Bytef*>(a_source),
                          static_cast<uLong>(a_sourceLength), Z_BEST_SPEED);
  if (result != Z_OK)
  {
    XM_LOG(xmlog::error, "Unable to write file. Compression failed.")
    return -1;
  }

  return static_cast<int32_t>(compressedLength);
} // iCompress
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
bool iUncompress(const char* a_source, int32_t a_sourceLength, char* a_dest, int32_t a_destLength)
{
  auto uncompressedLength = static_cast<uLong>(a_destLength);
  bool success = uncompress(reinterpret_cast<Bytef*>(a_dest), &uncompressedLength,
                            reinterpret_cast<const Bytef*>(a_source),
                            static_cast<uLong>(a_sourceLength)) == Z_OK;
  success = success && static_cast<int32_t>(uncompressedLength) == a_destLength;
  if (!success)
  {
    XM_LOG(xmlog::error, "Unable to read file. Unable to uncompress data.")
    return false;
  }

  return true;
} // iCompress
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
int32_t iBase64EncodeSize(int32_t a_sourceLength)
{
  unsigned long length = ((4U * static_cast<unsigned long>(a_sourceLength) / 3U) + 3U) & ~3U;
  return static_cast<int32_t>(length);
} // iBase64EncodeSize
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
int32_t iBase64Encode(const char* a_source, int32_t a_sourceLength, char* a_dest)
{
  using namespace boost::archive::iterators;
  typedef base64_from_binary<transform_width<const char*, 6, 8>> base64_text;

  const char* srcBegin = a_source;
  const char* srcEnd = srcBegin + a_sourceLength;
  char* destBegin = a_dest;
  char* destIterator = a_dest;
  for (auto it = base64_text(srcBegin); it != base64_text(srcEnd); ++it)
    *destIterator++ = *it;
  *destIterator = 0;

  auto encodedLength = int32_t(destIterator - destBegin);
  return encodedLength;
} // iBase64Encode
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
int32_t iBase64Decode(const char* a_source, int32_t a_sourceLength, char* a_dest)
{
  using namespace boost::archive::iterators;
  typedef transform_width<binary_from_base64<const char*>, 8, 6> base64_dec;

  int32_t size = a_sourceLength;
  if (size && a_source[size - 1] == '=')
  {
    --size;
    if (size && a_source[size - 1] == '=')
      --size;
  }

  if (size != 0)
  {
    char* destBegin = a_dest;
    char* destIterator = a_dest;
    auto base64Begin = base64_dec(a_source);
    auto base64End = base64_dec(a_source + size);
    for (auto it = base64Begin; it != base64End; ++it)
      *destIterator++ = *it;

    auto decodedLength = int32_t(destIterator - destBegin);
    return decodedLength;
  }

  return 0;
} // iBase64Decode
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
bool iReadLineToSStream(std::istream& a_inStream, const char* a_name, std::stringstream& a_ss)
{
  std::string line;
  if (!daReadLine(a_inStream, line))
    return false;

  auto position = line.find(a_name);
  if (position == std::string::npos)
    return false;
  else
  {
    for (size_t i = 0; i < position; ++i)
    {
      if (!isspace(line[i]))
        return false;
    }
  }

  a_ss.clear();
  std::replace(line.begin(), line.end(), ',', ' ');
  a_ss.str(line.substr(position));
  return !a_ss.fail();
} // iReadLineToSStream
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
template <typename _T>
bool iReadLineValue(std::istream& a_inStream, _T& a_val)
{
  std::string line;
  if (!daReadLine(a_inStream, line))
    return false;
  std::stringstream ss;
  ss.str(line);
  ss >> a_val;
  return !ss.fail();
} // iReadLineValue
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
template <typename _T>
bool iReadVector(std::istream& a_inStream, const char* a_name, std::vector<_T>& a_vec)
{
  a_vec.clear();
  int size;
  if (!daReadIntLine(a_inStream, a_name, size))
    return false;
  for (int ii = 0; ii < size; ++ii)
  {
    _T val;
    if (!iReadLineValue(a_inStream, val))
      return false;
    a_vec.push_back(val);
  }
  return true;
} // iReadVector
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
template <typename _T>
bool iReadValue(std::istream& a_inStream, const char* a_name, _T& a_d1)
{
  std::stringstream ss;
  if (!iReadLineToSStream(a_inStream, a_name, ss))
    return false;
  std::string name;
  ss >> name;
  ss >> a_d1;
  return !ss.fail();
} // iReadValue
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
template <typename _T>
bool iRead3Values(std::istream& a_inStream, const char* a_name, _T& d1, _T& d2, _T& d3)
{
  std::stringstream ss;
  if (!iReadLineToSStream(a_inStream, a_name, ss))
    return false;
  std::string name;
  ss >> name;
  ss >> d1;
  ss >> d2;
  ss >> d3;
  return !ss.fail();
} // iRead3Values
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
template <typename _T>
bool iRead2Values(std::istream& a_inStream, const char* a_name, _T& d1, _T& d2)
{
  std::stringstream ss;
  if (!iReadLineToSStream(a_inStream, a_name, ss))
    return false;
  std::string name;
  ss >> name;
  ss >> d1;
  ss >> d2;
  return !ss.fail();
} // iRead2Values
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
template <typename _T>
bool iReadValueFromLine(std::string& a_line, _T& a_val)
{
  std::string line = a_line;
  std::string stringValue;
  if (!daReadStringFromLine(line, stringValue))
    return false;

  std::istringstream inStream(stringValue);
  _T tempVal;
  inStream >> tempVal;
  if (inStream.fail() || !inStream.eof())
    return false;
  a_val = tempVal;
  a_line = line;
  return true;
} // iReadValueFromLine

} // namespace

//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
DaStreamReader::DaStreamReader(std::istream& a_inStream, bool a_binaryArrays /*= false*/)
: m_impl(new Impl(a_inStream, a_binaryArrays))
{
} // DaStreamReader::DaStreamReader
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
DaStreamReader::~DaStreamReader()
{
} // DaStreamReader::~DaStreamReader
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
bool DaStreamReader::IsBinary() const
{
  return m_impl->m_binaryArrays;
} // DaStreamReader::IsBinary
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
bool DaStreamReader::ReadNamedLine(const char* a_name)
{
  std::stringstream ss;
  return iReadLineToSStream(m_impl->m_inStream, a_name, ss);
} // DaStreamReader::ReadNamedLine
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
bool DaStreamReader::ReadLine(std::string& a_line)
{
  a_line.clear();

  // The characters in the stream are read one-by-one using a std::streambuf.
  // That is faster than reading them one-by-one using the std::istream.
  // Code that uses streambuf this way must be guarded by a sentry object.
  // The sentry object performs various tasks,
  // such as thread synchronization and updating the stream state.

  std::istream::sentry se(m_impl->m_inStream, true);
  std::streambuf* sb = m_impl->m_inStream.rdbuf();

  for (;;)
  {
    int c = sb->sbumpc();
    if (c == '\n')
    {
      return !!m_impl->m_inStream;
    }

    if (c == '\r')
    {
      if (sb->sgetc() == '\n')
        sb->sbumpc();
      return !!m_impl->m_inStream;
    }

    if (c == std::streambuf::traits_type::eof())
    {
      // Also handle the case when the last line has no line ending
      if (a_line.empty())
        m_impl->m_inStream.setstate(std::ios::eofbit);
      return !!m_impl->m_inStream;
    }

    a_line += static_cast<char>(c);
  }
} // DaStreamReader::ReadLine
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
bool DaStreamReader::ReadIntLine(const char* a_name, int& a_val)
{
  return iReadValue(m_impl->m_inStream, a_name, a_val);
} // DaStreamReader::ReadIntLine
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
bool DaStreamReader::ReadDoubleLine(const char* a_name, double& a_val)
{
  return iReadValue(m_impl->m_inStream, a_name, a_val);
} // DaStreamReader::ReadDoubleLine
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
bool DaStreamReader::ReadStringLine(const char* a_name, std::string& a_val)
{
  return iReadValue(m_impl->m_inStream, a_name, a_val);
} // DaStreamReader::ReadStringLine
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
bool DaStreamReader::ReadVecInt(const char* a_name, VecInt& a_vec)
{
  if (IsBinary())
  {
    int size;
    if (!ReadIntLine(a_name, size))
      return false;

    a_vec.resize(size);
    if (size != 0)
      ReadBinaryBytes(reinterpret_cast<char*>(&a_vec[0]), size * sizeof(VecInt::value_type));
    return true;
  }

  return iReadVector(m_impl->m_inStream, a_name, a_vec);
} // DaStreamReader::ReadVecInt
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
bool DaStreamReader::ReadVecDbl(const char* a_name, VecDbl& a_vec)
{
  if (IsBinary())
  {
    int size;
    if (!ReadIntLine(a_name, size))
      return false;

    a_vec.resize(size);
    if (size != 0)
      ReadBinaryBytes(reinterpret_cast<char*>(&a_vec[0]), size * sizeof(VecDbl::value_type));
    return true;
  }

  return iReadVector(m_impl->m_inStream, a_name, a_vec);
} // DaStreamReader::ReadVecDbl
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
bool DaStreamReader::ReadVecPt3d(const char* a_name, VecPt3d& a_vec)
{
  int size;
  if (!daReadIntLine(m_impl->m_inStream, a_name, size))
    return false;

  if (IsBinary())
  {
    a_vec.resize(size);
    if (size != 0)
      ReadBinaryBytes(reinterpret_cast<char*>(&a_vec[0]), size * sizeof(VecPt3d::value_type));
  }
  else
  {
    a_vec.resize(0);
    a_vec.reserve(size);
    std::string pointLine;
    std::string pointValue;
    for (int i = 0; i < size; ++i)
    {
      if (!daReadLine(m_impl->m_inStream, pointLine))
        return false;

      bool success = daReadStringFromLine(pointLine, pointValue);
      success = success && pointValue == "POINT";
      int readPointIdx = -1;
      success = success && daReadIntFromLine(pointLine, readPointIdx);
      success = success && readPointIdx == static_cast<int>(i);
      Pt3d pt;
      success = success && daReadDoubleFromLine(pointLine, pt.x);
      success = success && daReadDoubleFromLine(pointLine, pt.y);
      success = success && daReadDoubleFromLine(pointLine, pt.z);
      if (!success)
        return false;
      a_vec.push_back(pt);
    }
  }

  return true;
} // DaStreamReader::ReadVecPt3d
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
bool DaStreamReader::Read2StringLine(const char* a_name, std::string& a_val1, std::string& a_val2)
{
  return iRead2Values(m_impl->m_inStream, a_name, a_val1, a_val2);
} // DaStreamReader::Read2StringLine
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
bool DaStreamReader::Read3StringLine(const char* a_name,
                                     std::string& a_val1,
                                     std::string& a_val2,
                                     std::string& a_val3)
{
  return iRead3Values(m_impl->m_inStream, a_name, a_val1, a_val2, a_val3);
} // DaStreamReader::Read3StringLine
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
bool DaStreamReader::Read3DoubleLine(const char* a_name,
                                     double& a_val1,
                                     double& a_val2,
                                     double& a_val3)
{
  return iRead3Values(m_impl->m_inStream, a_name, a_val1, a_val2, a_val3);
} // DaStreamReader::Read3DoubleLine
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
bool DaStreamReader::ReadIntFromLine(std::string& a_line, int& a_val)
{
  return iReadValueFromLine(a_line, a_val);
} // DaStreamReader::ReadIntFromLine
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
bool DaStreamReader::ReadStringFromLine(std::string& a_line, std::string& a_val)
{
  std::istringstream inStream(a_line);
  inStream >> a_val;
  if (inStream.fail())
    return false;
  size_t position = inStream.tellg();
  if (position != std::string::npos)
    a_line = inStream.str().substr(position);
  else
    a_line = "";
  return true;
} // DaStreamReader::ReadStringFromLine
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
bool DaStreamReader::ReadDoubleFromLine(std::string& a_line, double& a_val)
{
  return iReadValueFromLine(a_line, a_val);
} // DaStreamReader::ReadDoubleFromLine
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
bool DaStreamReader::ReadString(std::string& a_val)
{
  m_impl->m_inStream >> a_val;
  return !m_impl->m_inStream.fail();
} // DaStreamReader::ReadString
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
bool DaStreamReader::ReadInt(int& a_val)
{
  m_impl->m_inStream >> a_val;
  return !m_impl->m_inStream.fail();
} // DaStreamReader::ReadInt
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
bool DaStreamReader::NextLine()
{
  std::string line;
  ReadLine(line);
  return !m_impl->m_inStream.fail();
} // DaStreamReader::NextLine
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
bool DaStreamReader::ReadBinaryBytes(char* a_dest, long long a_destLength)
{
  auto maxCompressedLength = static_cast<int32_t>(compressBound(MAX_BLOCK_SIZE));
  int32_t maxEncodeLength = iBase64EncodeSize(maxCompressedLength);
  std::unique_ptr<char[]> compressed(new char[maxCompressedLength]);
  std::unique_ptr<char[]> encoded(new char[maxEncodeLength + 1]);

  while (a_destLength > 0)
  {
    // read block info
    std::string blockString;
    int32_t encodedLength;
    int32_t blockLength;
    ReadString(blockString);
    ReadInt(encodedLength);
    ReadInt(blockLength);
    NextLine();

    // read and decode
    m_impl->m_inStream.read(encoded.get(), encodedLength);
    NextLine();

    auto compressedLength = iBase64Decode(encoded.get(), encodedLength, compressed.get());

    // decompress data
    if (!iUncompress(compressed.get(), compressedLength, a_dest, blockLength))
      return false;

    a_dest += blockLength;
    a_destLength -= blockLength;
  }

  return true;
} // DaStreamReader::ReadBinaryBytes
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
bool DaStreamReader::LineBeginsWith(const char* a_text)
{
  return daLineBeginsWith(m_impl->m_inStream, a_text);
} // DaStreamReader::LineBeginsWith

//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
DaStreamWriter::DaStreamWriter(std::ostream& a_outStream, bool a_binaryArrays /*= false*/)
: m_impl(new Impl(a_outStream, a_binaryArrays))
{
} // DaStreamWriter::DaStreamWriter
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
DaStreamWriter::~DaStreamWriter()
{
} // DaStreamWriter::~DaStreamWriter
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
bool DaStreamWriter::IsBinary() const
{
  return m_impl->m_binaryArrays;
} // DaStreamWriter::IsBinary
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void DaStreamWriter::WriteLine(const std::string& a_line)
{
  daWriteLine(m_impl->m_outStream, a_line);
} // DaStreamWriter::WriteLine
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void DaStreamWriter::WriteStringLine(const char* a_name, const std::string& a_val)
{
  daWriteStringLine(m_impl->m_outStream, a_name, a_val);
} // DaStreamWriter::WriteStringLine
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void DaStreamWriter::WriteIntLine(const char* a_name, int a_val)
{
  daWriteIntLine(m_impl->m_outStream, a_name, a_val);
} // DaStreamWriter::WriteIntLine
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void DaStreamWriter::WriteDoubleLine(const char* a_name, double a_val)
{
  daWriteDoubleLine(m_impl->m_outStream, a_name, a_val);
} // DaStreamWriter::WriteDoubleLine
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void DaStreamWriter::WriteVecInt(const char* a_name, const VecInt& a_vec)
{
  if (IsBinary())
  {
    m_impl->m_outStream << a_name << ' ' << a_vec.size() << '\n';
    if (!a_vec.empty())
      WriteBinaryBytes(reinterpret_cast<const char*>(&a_vec[0]),
                       a_vec.size() * sizeof(VecInt::value_type));
  }
  else
  {
    daWriteVecInt(m_impl->m_outStream, a_name, a_vec);
  }
} // DaStreamWriter::WriteVecInt
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void DaStreamWriter::WriteVecDbl(const char* a_name, const VecDbl& a_vec)
{
  if (IsBinary())
  {
    m_impl->m_outStream << a_name << ' ' << a_vec.size() << '\n';
    if (!a_vec.empty())
      WriteBinaryBytes(reinterpret_cast<const char*>(&a_vec[0]),
                       a_vec.size() * sizeof(VecDbl::value_type));
  }
  else
  {
    daWriteVecDbl(m_impl->m_outStream, a_name, a_vec);
  }
} // DaStreamWriter::WriteVecDbl
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void DaStreamWriter::WriteVecPt3d(const char* a_name, const VecPt3d& a_points)
{
  if (IsBinary())
  {
    m_impl->m_outStream << a_name << ' ' << a_points.size() << '\n';
    if (!a_points.empty())
      WriteBinaryBytes(reinterpret_cast<const char*>(&a_points[0]),
                       a_points.size() * sizeof(VecPt3d::value_type));
  }
  else
  {
    daWriteVecPt3d(m_impl->m_outStream, a_name, a_points);
  }
} // DaStreamWriter::WriteVecPt3d
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void DaStreamWriter::Write2StringLine(const char* a_name,
                                      const std::string& a_val1,
                                      const std::string& a_val2)
{
  daWrite2StringLine(m_impl->m_outStream, a_name, a_val1, a_val2);
} // DaStreamWriter::Write2StringLine
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void DaStreamWriter::Write3StringLine(const char* a_name,
                                      const std::string& a_val1,
                                      const std::string& a_val2,
                                      const std::string& a_val3)
{
  daWrite3StringLine(m_impl->m_outStream, a_name, a_val1, a_val2, a_val3);
} // DaStreamWriter::Write3StringLine
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void DaStreamWriter::Write3DoubleLine(const char* a_name,
                                      const double& a_val1,
                                      const double& a_val2,
                                      const double& a_val3)
{
  daWrite3DoubleLine(m_impl->m_outStream, a_name, a_val1, a_val2, a_val3);
} // DaStreamWriter::Write3DoubleLine
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void DaStreamWriter::WriteString(const char* a_string)
{
  m_impl->m_outStream << a_string;
} // DaStreamWriter::WriteString
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void DaStreamWriter::AppendInt(int a_val)
{
  m_impl->m_outStream << ' ' << a_val;
} // DaStreamWriter::AppendInt
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void DaStreamWriter::AppendInts(const int* a_values, int a_numValues)
{
  for (int i = 0; i < a_numValues; ++i)
    m_impl->m_outStream << ' ' << *a_values++;
} // DaStreamWriter::AppendInts
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void DaStreamWriter::AppendString(const std::string& a_val)
{
  m_impl->m_outStream << ' ' << a_val;
} // DaStreamWriter::AppendString
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void DaStreamWriter::EndLine()
{
  m_impl->m_outStream << '\n';
} // DaStreamWriter::EndLine
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
bool DaStreamWriter::WriteBinaryBytes(const char* a_source, long long a_sourceLength)
{
  auto maxCompressedLength = static_cast<int32_t>(compressBound(m_impl->m_blockSize));
  int32_t maxEncodeLength = iBase64EncodeSize(maxCompressedLength);
  std::unique_ptr<char[]> compressed(new char[maxCompressedLength]);
  std::unique_ptr<char[]> encoded(new char[maxEncodeLength + 1]);

  while (a_sourceLength > 0)
  {
    // compress a block
    int32_t blockLength = a_sourceLength < m_impl->m_blockSize
                            ? static_cast<int32_t>(a_sourceLength)
                            : m_impl->m_blockSize;
    int32_t compressedLength =
      iCompress(a_source, blockLength, compressed.get(), maxCompressedLength);
    if (compressedLength < 0)
      return false;
    a_sourceLength -= blockLength;
    a_source += blockLength;

    // encode a block
    int32_t encodedLength = iBase64Encode(compressed.get(), compressedLength, encoded.get());

    // write block info
    WriteString("BINARY_BLOCK");
    AppendInt(encodedLength);
    AppendInt(blockLength);
    EndLine();
    m_impl->m_outStream.write(encoded.get(), encodedLength);
    EndLine();
  }

  return true;
} // DaStreamWriter::WriteBinaryBytes
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void DaStreamWriter::SetBinaryBlockSize(int a_blockSize)
{
  m_impl->m_blockSize = a_blockSize > MAX_BLOCK_SIZE ? MAX_BLOCK_SIZE : a_blockSize;
} // DaStreamWriter::SetBinaryBlockSize

//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
bool daReadNamedLine(std::istream& a_inStream, const char* a_name)
{
  std::stringstream ss;
  return iReadLineToSStream(a_inStream, a_name, ss);
} // daReadNamedLine
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
bool daReadLine(std::istream& a_inStream, std::string& a_line)
{
  a_line.clear();

  // The characters in the stream are read one-by-one using a std::streambuf.
  // That is faster than reading them one-by-one using the std::istream.
  // Code that uses streambuf this way must be guarded by a sentry object.
  // The sentry object performs various tasks,
  // such as thread synchronization and updating the stream state.

  std::istream::sentry se(a_inStream, true);
  std::streambuf* sb = a_inStream.rdbuf();

  for (;;)
  {
    int c = sb->sbumpc();
    if (c == '\n')
    {
      return !!a_inStream;
    }

    if (c == '\r')
    {
      if (sb->sgetc() == '\n')
        sb->sbumpc();
      return !!a_inStream;
    }

    if (c == std::streambuf::traits_type::eof())
    {
      // Also handle the case when the last line has no line ending
      if (a_line.empty())
        a_inStream.setstate(std::ios::eofbit);
      return !!a_inStream;
    }

    a_line += (char)c;
  }
} // daReadLine
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
bool daReadIntLine(std::istream& a_inStream, const char* a_name, int& a_val)
{
  return iReadValue(a_inStream, a_name, a_val);
} // daReadIntLine
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
bool daReadDoubleLine(std::istream& a_inStream, const char* a_name, double& a_val)
{
  return iReadValue(a_inStream, a_name, a_val);
} // daReadDoubleLine
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
bool daReadStringLine(std::istream& a_inStream, const char* a_name, std::string& a_val)
{
  return iReadValue(a_inStream, a_name, a_val);
} // daReadStringLine
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
bool daReadVecInt(std::istream& a_inStream, const char* a_name, VecInt& a_vec)
{
  return iReadVector(a_inStream, a_name, a_vec);
} // daReadVecInt
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
bool daReadVecDbl(std::istream& a_inStream, const char* a_name, VecDbl& a_vec)
{
  return iReadVector(a_inStream, a_name, a_vec);
} // daReadVecDbl
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
bool daReadVecPt3d(std::istream& a_inStream, const char* a_name, VecPt3d& a_vec)
{
  int size;
  if (!daReadIntLine(a_inStream, a_name, size))
    return false;

  a_vec.resize(0);
  a_vec.reserve(size);
  std::string pointLine;
  std::string pointValue;
  for (int i = 0; i < size; ++i)
  {
    if (!daReadLine(a_inStream, pointLine))
      return false;

    bool success = daReadStringFromLine(pointLine, pointValue);
    success = success && pointValue == "POINT";
    int readPointIdx = -1;
    success = success && daReadIntFromLine(pointLine, readPointIdx);
    success = success && readPointIdx == (int)i;
    Pt3d pt;
    success = success && daReadDoubleFromLine(pointLine, pt.x);
    success = success && daReadDoubleFromLine(pointLine, pt.y);
    success = success && daReadDoubleFromLine(pointLine, pt.z);
    if (!success)
      return false;
    a_vec.push_back(pt);
  }

  return true;
} // daReadVecPt3d
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
bool daRead2StringLine(std::istream& a_inStream,
                       const char* a_name,
                       std::string& a_val1,
                       std::string& a_val2)
{
  return iRead2Values(a_inStream, a_name, a_val1, a_val2);
} // daRead2StringLine
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
bool daRead3StringLine(std::istream& a_inStream,
                       const char* a_name,
                       std::string& a_val1,
                       std::string& a_val2,
                       std::string& a_val3)
{
  return iRead3Values(a_inStream, a_name, a_val1, a_val2, a_val3);
} // daRead3StringLine
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
bool daRead3DoubleLine(std::istream& a_inStream,
                       const char* a_name,
                       double& a_val1,
                       double& a_val2,
                       double& a_val3)
{
  return iRead3Values(a_inStream, a_name, a_val1, a_val2, a_val3);
} // daRead3DoubleLine
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
bool daReadIntFromLine(std::string& a_line, int& a_val)
{
  return iReadValueFromLine(a_line, a_val);
} // daReadIntFromLine
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
bool daReadStringFromLine(std::string& a_line, std::string& a_val)
{
  std::istringstream inStream(a_line);
  inStream >> a_val;
  if (inStream.fail())
    return false;
  size_t position = inStream.tellg();
  if (position != std::string::npos)
    a_line = inStream.str().substr(position);
  else
    a_line = "";
  return true;
} // daReadStringFromLine
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
bool daReadDoubleFromLine(std::string& a_line, double& a_val)
{
  return iReadValueFromLine(a_line, a_val);
} // daReadDoubleFromLine
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
bool daLineBeginsWith(std::istream& a_inStream, const std::string& a_text)
{
  auto streamPosition = a_inStream.tellg();
  bool foundText = false;
  std::string line;
  if (daReadLine(a_inStream, line))
  {
    foundText = line.find(a_text) == 0;
  }

  a_inStream.seekg(streamPosition);
  return foundText;
} // daLineBeginsWith
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void daWriteNamedLine(std::ostream& a_outStream, const char* a_name)
{
  a_outStream << a_name << '\n';
} // daWriteNamedLine
  //------------------------------------------------------------------------------
  //------------------------------------------------------------------------------
void daWriteLine(std::ostream& a_outStream, const std::string& a_line)
{
  a_outStream << a_line << '\n';
} // daWriteLine
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void daWriteDoubleLine(std::ostream& a_outStream, const char* a_name, double a_val)
{
  StTemp2DigitExponents temp2DigitExponents;
  a_outStream << a_name << ' ' << STRstd(a_val) << '\n';
} // daWriteDoubleLine
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void daWriteStringLine(std::ostream& a_outStream, const char* a_name, const std::string& a_val)
{
  a_outStream << a_name << ' ' << a_val << '\n';
} // daWriteStringLine
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void daWriteVecInt(std::ostream& a_outStream, const char* a_name, const VecInt& a_vec)
{
  size_t size = a_vec.size();
  a_outStream << a_name << ' ' << size << '\n';
  for (auto val : a_vec)
  {
    a_outStream << "  " << val << '\n';
  }
} // daWriteVecInt
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void daWrite2StringLine(std::ostream& a_outStream,
                        const char* a_name,
                        const std::string& a_val1,
                        const std::string& a_val2)
{
  a_outStream << a_name << ' ' << a_val1 << ' ' << a_val2 << '\n';
} // daWrite2StringLine
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void daWrite3StringLine(std::ostream& a_outStream,
                        const char* a_name,
                        const std::string& a_val1,
                        const std::string& a_val2,
                        const std::string& a_val3)
{
  a_outStream << a_name << ' ' << a_val1 << ' ' << a_val2 << ' ' << a_val3 << '\n';
} // daWrite3StringLine
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void daWrite3DoubleLine(std::ostream& a_outStream,
                        const char* a_name,
                        const double& a_val1,
                        const double& a_val2,
                        const double& a_val3)
{
  a_outStream << a_name << ' ' << STRstd(a_val1) << ' ' << STRstd(a_val2) << ' ' << STRstd(a_val3)
              << '\n';
} // daWrite3DoubleLine
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void daWriteIntLine(std::ostream& a_outStream, const char* a_name, int a_val)
{
  a_outStream << a_name << ' ' << a_val << '\n';
} // daWriteIntLine
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void daWriteVecDbl(std::ostream& a_outStream, const char* a_name, const VecDbl& a_vec)
{
  StTemp2DigitExponents temp2DigitExponents;
  size_t size = a_vec.size();
  a_outStream << a_name << ' ' << size << '\n';
  for (auto val : a_vec)
  {
    a_outStream << "  " << STRstd(val) << '\n';
  }
} // daWriteVecDbl
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void daWriteVecPt3d(std::ostream& a_outStream, const char* a_name, const VecPt3d& a_points)
{
  // write name and size of vector
  a_outStream << a_name << ' ' << a_points.size() << '\n';

  // write each indented point and XYZ (why not remove POINT text?)
  StTemp2DigitExponents use2DigitExponents;
  for (size_t i = 0; i < a_points.size(); ++i)
  {
    const Pt3d& point = a_points[i];
    std::string sx(STRstd(point.x));
    std::string sy(STRstd(point.y));
    std::string sz(STRstd(point.z));
    a_outStream << "  POINT " << i << ' ' << sx << ' ' << sy << ' ' << sz << '\n';
  }
} // daWriteVecPt3d

} // namespace xms

#if CXX_TEST
// TESTS

#include <xmscore/dataio/daStreamIo.t.h>

#include <numeric>

using namespace xms;

//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void DaStreamIoUnitTests::testReadNamedLine()
{
  // test read with CR LF, LF, CR, and no line endings
  std::string lineEndingsInput =
    "Windows Line\r\n"
    "Unix Line\n"
    "Mac Line\r"
    "Last Line";
  std::istringstream inStream(lineEndingsInput);
  TS_ASSERT(daReadNamedLine(inStream, "Windows Line"));
  TS_ASSERT(daReadNamedLine(inStream, "Unix Line"));
  TS_ASSERT(daReadNamedLine(inStream, "Mac Line"));
  TS_ASSERT(daReadNamedLine(inStream, "Last Line"));
} // DaStreamIoUnitTests::testReadNamedLine
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void DaStreamIoUnitTests::testReadWriteLine()
{
  std::ostringstream outputStream;
  daWriteLine(outputStream, "daWriteLine version 1.0");
  std::string expected = "daWriteLine version 1.0\n";
  std::string found = outputStream.str();
  TS_ASSERT_EQUALS(expected, found);

  std::istringstream inputStream(outputStream.str());
  std::string value;
  daReadLine(inputStream, value);
  expected = "daWriteLine version 1.0";
  TS_ASSERT_EQUALS(expected, value);

  // test read with CR LF, LF, CR, and no line endings
  std::string lineEndingsInput =
    "Windows Line\r\n"
    "Unix Line\n"
    "Mac Line\r"
    "Last Line";
  std::istringstream endingsIn(lineEndingsInput);
  daReadLine(endingsIn, value);
  TS_ASSERT_EQUALS("Windows Line", value);
  daReadLine(endingsIn, value);
  TS_ASSERT_EQUALS("Unix Line", value);
  daReadLine(endingsIn, value);
  TS_ASSERT_EQUALS("Mac Line", value);
  daReadLine(endingsIn, value);
  TS_ASSERT_EQUALS("Last Line", value);
} // DaStreamIoUnitTests::testReadWriteLine
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void DaStreamIoUnitTests::testReadWriteStringLine()
{
  std::ostringstream outputStream;
  const char* name = "LINE_NAME";
  std::string expectedValue = "VALUE";
  daWriteStringLine(outputStream, name, expectedValue);
  std::string expected = "LINE_NAME VALUE\n";
  std::string found = outputStream.str();
  TS_ASSERT_EQUALS(expected, found);

  std::istringstream inputStream(outputStream.str());
  std::string foundValue;
  TS_ASSERT(daReadStringLine(inputStream, name, foundValue));
  TS_ASSERT_EQUALS(expectedValue, foundValue);
} // DaStreamIoUnitTests::testReadWriteStringLine
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void DaStreamIoUnitTests::testReadWrite2StringLine()
{
  std::ostringstream outputStream;
  const char* name = "LINE_NAME";
  std::string expectedValue1 = "VALUE1";
  std::string expectedValue2 = "VALUE2";
  daWrite2StringLine(outputStream, name, expectedValue1, expectedValue2);
  std::string expected = "LINE_NAME VALUE1 VALUE2\n";
  std::string found = outputStream.str();
  TS_ASSERT_EQUALS(expected, found);

  std::istringstream inputStream(outputStream.str());
  std::string foundValue1;
  std::string foundValue2;
  TS_ASSERT(daRead2StringLine(inputStream, name, foundValue1, foundValue2));
  TS_ASSERT_EQUALS(expectedValue1, foundValue1);
  TS_ASSERT_EQUALS(expectedValue2, foundValue2);
} // DaStreamIoUnitTests::testReadWrite2StringLine
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void DaStreamIoUnitTests::testReadWrite3StringLine()
{
  std::ostringstream outputStream;
  const char* name = "LINE_NAME";
  std::string expectedValue1 = "VALUE1";
  std::string expectedValue2 = "VALUE2";
  std::string expectedValue3 = "VALUE3";
  daWrite3StringLine(outputStream, name, expectedValue1, expectedValue2, expectedValue3);
  std::string expected = "LINE_NAME VALUE1 VALUE2 VALUE3\n";
  std::string found = outputStream.str();
  TS_ASSERT_EQUALS(expected, found);

  std::istringstream inputStream(outputStream.str());
  std::string foundValue1;
  std::string foundValue2;
  std::string foundValue3;
  TS_ASSERT(daRead3StringLine(inputStream, name, foundValue1, foundValue2, foundValue3));
  TS_ASSERT_EQUALS(expectedValue1, foundValue1);
  TS_ASSERT_EQUALS(expectedValue2, foundValue2);
  TS_ASSERT_EQUALS(expectedValue3, foundValue3);
} // DaStreamIoUnitTests::testReadWrite3StringLine
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void DaStreamIoUnitTests::testReadIntFromLine()
{
  std::string line;

  // read from front
  int intValue;
  line = "1 -1 A 2.0 B 4";
  TS_ASSERT(daReadIntFromLine(line, intValue));
  TS_ASSERT_EQUALS(1, intValue);
  TS_ASSERT_EQUALS(" -1 A 2.0 B 4", line);

  // read second value (with a space)
  line = " -1 A 2.0 B 4";
  TS_ASSERT(daReadIntFromLine(line, intValue));
  TS_ASSERT_EQUALS(-1, intValue);
  TS_ASSERT_EQUALS(" A 2.0 B 4", line);

  // fails to read alpha (int value stays the same)
  line = " A 2.0 B 4";
  intValue = -1;
  TS_ASSERT(!daReadIntFromLine(line, intValue));
  TS_ASSERT_EQUALS(-1, intValue);
  TS_ASSERT_EQUALS(" A 2.0 B 4", line);

  // fails to read double (int value stays the same)
  line = " A 2.0 B 4";
  intValue = -1;
  TS_ASSERT(!daReadIntFromLine(line, intValue));
  TS_ASSERT_EQUALS(-1, intValue);
  TS_ASSERT_EQUALS(" A 2.0 B 4", line);

  // fails with empty line
  line = "";
  intValue = -1;
  TS_ASSERT(!daReadIntFromLine(line, intValue));
  TS_ASSERT_EQUALS(-1, intValue);
  TS_ASSERT_EQUALS("", line);
} // DaStreamIoUnitTests::testReadIntFromLine
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void DaStreamIoUnitTests::testReadStringFromLine()
{
  std::string line;

  // read from front
  std::string stringValue;
  line = "value1 value2 3";
  TS_ASSERT(daReadStringFromLine(line, stringValue));
  TS_ASSERT_EQUALS("value1", stringValue);
  TS_ASSERT_EQUALS(" value2 3", line);

  // read second value (with a space)
  line = " value2 value3";
  TS_ASSERT(daReadStringFromLine(line, stringValue));
  TS_ASSERT_EQUALS("value2", stringValue);
  TS_ASSERT_EQUALS(" value3", line);

  // read last value
  line = "3";
  TS_ASSERT(daReadStringFromLine(line, stringValue));
  TS_ASSERT_EQUALS("3", stringValue);
  TS_ASSERT_EQUALS("", line);

  // fails with empty line (string value stays the same)
  line = "";
  stringValue = "3";
  TS_ASSERT(!daReadStringFromLine(line, stringValue));
  TS_ASSERT_EQUALS("3", stringValue);
  TS_ASSERT_EQUALS("", line);
} // DaStreamIoUnitTests::testReadStringFromLine
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void DaStreamIoUnitTests::testReadDoubleFromLine()
{
  std::string line;

  // read from front
  double doubleValue;
  line = "1.1 -1.0e-3 3";
  TS_ASSERT(daReadDoubleFromLine(line, doubleValue));
  TS_ASSERT_EQUALS(1.1, doubleValue);
  TS_ASSERT_EQUALS(" -1.0e-3 3", line);

  // read second value (with a space)
  line = " -1.0e-3 3";
  TS_ASSERT(daReadDoubleFromLine(line, doubleValue));
  TS_ASSERT_EQUALS(-1.0e-3, doubleValue);
  TS_ASSERT_EQUALS(" 3", line);

  // read last value
  line = "3";
  TS_ASSERT(daReadDoubleFromLine(line, doubleValue));
  TS_ASSERT_EQUALS(3, doubleValue);
  TS_ASSERT_EQUALS("", line);

  // fails with empty line (string value stays the same)
  line = "";
  doubleValue = 3;
  TS_ASSERT(!daReadDoubleFromLine(line, doubleValue));
  TS_ASSERT_EQUALS(3, doubleValue);
  TS_ASSERT_EQUALS("", line);
} // DaStreamIoUnitTests::testReadDoubleFromLine
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void DaStreamIoUnitTests::testReadWriteIntLine()
{
  std::ostringstream outputStream;
  const char* name = "LINE_NAME";
  const int expect = 22;
  daWriteIntLine(outputStream, name, expect);
  std::string outputExpected = "LINE_NAME 22\n";
  std::string outputFound = outputStream.str();
  TS_ASSERT_EQUALS(outputExpected, outputFound);

  std::istringstream inputStream(outputStream.str());
  int found;
  TS_ASSERT(daReadIntLine(inputStream, name, found));
  TS_ASSERT_EQUALS(expect, found);
} // DaStreamIoUnitTests::testReadWriteIntLine
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void DaStreamIoUnitTests::testReadWriteDoubleLine()
{
  std::ostringstream outputStream;
  const char* name = "LINE_NAME";
  const double expect1 = 1.123e-20;
  const double expect2 = 2.0;
  daWriteDoubleLine(outputStream, name, expect1);
  daWriteDoubleLine(outputStream, name, expect2);
  std::string outputExpected = "LINE_NAME 1.123e-20\nLINE_NAME 2.0\n";
  std::string outputFound = outputStream.str();
  TS_ASSERT_EQUALS(outputExpected, outputFound);

  std::istringstream inputStream(outputStream.str());
  double found;
  TS_ASSERT(daReadDoubleLine(inputStream, name, found));
  TS_ASSERT_EQUALS(expect1, found);
  TS_ASSERT(daReadDoubleLine(inputStream, name, found));
  TS_ASSERT_EQUALS(expect2, found);
} // DaStreamIoUnitTests::testReadWriteDoubleLine
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void DaStreamIoUnitTests::testReadWrite3DoubleLine()
{
  std::ostringstream outputStream;
  const char* name = "LINE_NAME";
  const double expect1 = 560770.5;
  const double expect2 = 70055.4;
  const double expect3 = 22.3;
  daWrite3DoubleLine(outputStream, name, expect1, expect2, expect3);
  std::string outputExpected = "LINE_NAME 560770.5 70055.4 22.3\n";
  std::string outputFound = outputStream.str();
  TS_ASSERT_EQUALS(outputExpected, outputFound);

  std::istringstream inputStream(outputStream.str());
  double found1;
  double found2;
  double found3;
  TS_ASSERT(daRead3DoubleLine(inputStream, name, found1, found2, found3));
  TS_ASSERT_EQUALS(expect1, found1);
  TS_ASSERT_EQUALS(expect2, found2);
  TS_ASSERT_EQUALS(expect3, found3);
} // DaStreamIoUnitTests::testReadWrite3DoubleLine
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void DaStreamIoUnitTests::testReadWriteVecInt()
{
  std::ostringstream outputStream;
  const char* name = "VECTOR_NAME";
  const VecInt expect = {1, 2, 3};
  daWriteVecInt(outputStream, name, expect);
  std::string outputExpected =
    "VECTOR_NAME 3\n"
    "  1\n"
    "  2\n"
    "  3\n";
  std::string outputFound = outputStream.str();
  TS_ASSERT_EQUALS(outputExpected, outputFound);

  std::istringstream inputStream(outputStream.str());
  VecInt found;
  TS_ASSERT(daReadVecInt(inputStream, name, found));
  TS_ASSERT_EQUALS(expect, found);
} // DaStreamIoUnitTests::testReadWriteVecInt
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void DaStreamIoUnitTests::testReadWriteVecDbl()
{
  std::ostringstream outputStream;
  const char* name = "VECTOR_NAME";
  const VecDbl expect = {1.0, 2.2e-20, 3.3};
  daWriteVecDbl(outputStream, name, expect);
  std::string outputExpected =
    "VECTOR_NAME 3\n"
    "  1.0\n"
    "  2.2e-20\n"
    "  3.3\n";
  std::string outputFound = outputStream.str();
  TS_ASSERT_EQUALS(outputExpected, outputFound);

  std::istringstream inputStream(outputStream.str());
  VecDbl found;
  TS_ASSERT(daReadVecDbl(inputStream, name, found));
  TS_ASSERT_EQUALS(expect, found);
} // DaStreamIoUnitTests::testReadWriteVecDbl
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void DaStreamIoUnitTests::testReadWriteVecPt3d()
{
  std::ostringstream outputStream;
  const char* name = "VECTOR_NAME";
  const VecPt3d expect = {
    {1.0, 1.2, 1.3},
    {2.1, 2.2, 2.3e-20},
  };
  daWriteVecPt3d(outputStream, name, expect);
  std::string outputExpected =
    "VECTOR_NAME 2\n"
    "  POINT 0 1.0 1.2 1.3\n"
    "  POINT 1 2.1 2.2 2.3e-20\n";
  std::string outputFound = outputStream.str();
  TS_ASSERT_EQUALS(outputExpected, outputFound);

  std::istringstream inputStream(outputStream.str());
  VecPt3d found;
  TS_ASSERT(daReadVecPt3d(inputStream, name, found));
  TS_ASSERT_EQUALS(expect, found);
} // DaStreamIoUnitTests::testReadWriteVecPt3d
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void DaStreamIoUnitTests::testLineBeginsWith()
{
  const char* inputText =
    "VECTOR_NAME 2\n"
    "  POINT 0 1.1 1.2 1.3\n"
    "  POINT 1 2.1 2.2 2.3\n";
  std::istringstream inputStream(inputText);
  TS_ASSERT(daLineBeginsWith(inputStream, "VECTOR_NAME"));
  std::string line;
  TS_ASSERT(daReadLine(inputStream, line));
  TS_ASSERT_EQUALS("VECTOR_NAME 2", line);
  TS_ASSERT(daLineBeginsWith(inputStream, "  POINT"));
  TS_ASSERT(daReadLine(inputStream, line));
  TS_ASSERT_EQUALS("  POINT 0 1.1 1.2 1.3", line);
  TS_ASSERT(daLineBeginsWith(inputStream, "  POINT 1 2.1 2.2 2.3"));
  TS_ASSERT(daReadLine(inputStream, line));
  TS_ASSERT_EQUALS("  POINT 1 2.1 2.2 2.3", line);
} // DaStreamIoUnitTests::testLineBeginsWith
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void DaReaderWriterIoUnitTests::testReadNamedLine()
{
  // test read with CR LF, LF, CR, and no line endings
  std::string lineEndingsInput =
    "Windows Line\r\n"
    "Unix Line\n"
    "Mac Line\r"
    "Last Line";
  std::istringstream inStream(lineEndingsInput);
  DaStreamReader reader(inStream);
  TS_ASSERT(reader.ReadNamedLine("Windows Line"));
  TS_ASSERT(reader.ReadNamedLine("Unix Line"));
  TS_ASSERT(reader.ReadNamedLine("Mac Line"));
  TS_ASSERT(reader.ReadNamedLine("Last Line"));
} // DaReaderWriterIoUnitTests::testReadNamedLine
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void DaReaderWriterIoUnitTests::testReadWriteLine()
{
  std::ostringstream outputStream;
  DaStreamWriter writer(outputStream);
  writer.WriteLine("daWriteLine version 1.0");
  std::string expected = "daWriteLine version 1.0\n";
  std::string found = outputStream.str();
  TS_ASSERT_EQUALS(expected, found);

  std::istringstream inputStream(outputStream.str());
  DaStreamReader reader(inputStream);
  std::string value;
  reader.ReadLine(value);
  expected = "daWriteLine version 1.0";
  TS_ASSERT_EQUALS(expected, value);

  // test read with CR LF, LF, CR, and no line endings
  std::string lineEndingsInput =
    "Windows Line\r\n"
    "Unix Line\n"
    "Mac Line\r"
    "Last Line";
  std::istringstream endingsIn(lineEndingsInput);
  DaStreamReader readerIn(endingsIn);
  readerIn.ReadLine(value);
  TS_ASSERT_EQUALS("Windows Line", value);
  readerIn.ReadLine(value);
  TS_ASSERT_EQUALS("Unix Line", value);
  readerIn.ReadLine(value);
  TS_ASSERT_EQUALS("Mac Line", value);
  readerIn.ReadLine(value);
  TS_ASSERT_EQUALS("Last Line", value);
} // DaReaderWriterIoUnitTests::testReadWriteLine
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void DaReaderWriterIoUnitTests::testReadWriteStringLine()
{
  std::ostringstream outputStream;
  DaStreamWriter writer(outputStream);
  const char* name = "LINE_NAME";
  std::string expectedValue = "VALUE";
  writer.WriteStringLine(name, expectedValue);
  std::string expected = "LINE_NAME VALUE\n";
  std::string found = outputStream.str();
  TS_ASSERT_EQUALS(expected, found);

  std::istringstream inputStream(outputStream.str());
  DaStreamReader reader(inputStream);
  std::string foundValue;
  TS_ASSERT(reader.ReadStringLine(name, foundValue));
  TS_ASSERT_EQUALS(expectedValue, foundValue);
} // DaReaderWriterIoUnitTests::testReadWriteStringLine
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void DaReaderWriterIoUnitTests::testReadWrite2StringLine()
{
  std::ostringstream outputStream;
  DaStreamWriter writer(outputStream);
  const char* name = "LINE_NAME";
  std::string expectedValue1 = "VALUE1";
  std::string expectedValue2 = "VALUE2";
  writer.Write2StringLine(name, expectedValue1, expectedValue2);
  std::string expected = "LINE_NAME VALUE1 VALUE2\n";
  std::string found = outputStream.str();
  TS_ASSERT_EQUALS(expected, found);

  std::istringstream inputStream(outputStream.str());
  DaStreamReader reader(inputStream);
  std::string foundValue1;
  std::string foundValue2;
  TS_ASSERT(reader.Read2StringLine(name, foundValue1, foundValue2));
  TS_ASSERT_EQUALS(expectedValue1, foundValue1);
  TS_ASSERT_EQUALS(expectedValue2, foundValue2);
} // DaReaderWriterIoUnitTests::testReadWrite2StringLine
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void DaReaderWriterIoUnitTests::testReadWrite3StringLine()
{
  std::ostringstream outputStream;
  DaStreamWriter writer(outputStream);
  const char* name = "LINE_NAME";
  std::string expectedValue1 = "VALUE1";
  std::string expectedValue2 = "VALUE2";
  std::string expectedValue3 = "VALUE3";
  writer.Write3StringLine(name, expectedValue1, expectedValue2, expectedValue3);
  std::string expected = "LINE_NAME VALUE1 VALUE2 VALUE3\n";
  std::string found = outputStream.str();
  TS_ASSERT_EQUALS(expected, found);

  std::istringstream inputStream(outputStream.str());
  DaStreamReader reader(inputStream);
  std::string foundValue1;
  std::string foundValue2;
  std::string foundValue3;
  TS_ASSERT(reader.Read3StringLine(name, foundValue1, foundValue2, foundValue3));
  TS_ASSERT_EQUALS(expectedValue1, foundValue1);
  TS_ASSERT_EQUALS(expectedValue2, foundValue2);
  TS_ASSERT_EQUALS(expectedValue3, foundValue3);
} // DaReaderWriterIoUnitTests::testReadWrite3StringLine
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void DaReaderWriterIoUnitTests::testReadIntFromLine()
{
  // read from front
  int intValue;
  std::string line = "1 -1 A 2.0 B 4";
  TS_ASSERT(DaStreamReader::ReadIntFromLine(line, intValue));
  TS_ASSERT_EQUALS(1, intValue);
  TS_ASSERT_EQUALS(" -1 A 2.0 B 4", line);

  // read second value (with a space)
  line = " -1 A 2.0 B 4";
  TS_ASSERT(DaStreamReader::ReadIntFromLine(line, intValue));
  TS_ASSERT_EQUALS(-1, intValue);
  TS_ASSERT_EQUALS(" A 2.0 B 4", line);

  // fails to read alpha (int value stays the same)
  line = " A 2.0 B 4";
  intValue = -1;
  TS_ASSERT(!DaStreamReader::ReadIntFromLine(line, intValue));
  TS_ASSERT_EQUALS(-1, intValue);
  TS_ASSERT_EQUALS(" A 2.0 B 4", line);

  // fails to read double (int value stays the same)
  line = " A 2.0 B 4";
  intValue = -1;
  TS_ASSERT(!DaStreamReader::ReadIntFromLine(line, intValue));
  TS_ASSERT_EQUALS(-1, intValue);
  TS_ASSERT_EQUALS(" A 2.0 B 4", line);

  // fails with empty line
  line = "";
  intValue = -1;
  TS_ASSERT(!DaStreamReader::ReadIntFromLine(line, intValue));
  TS_ASSERT_EQUALS(-1, intValue);
  TS_ASSERT_EQUALS("", line);
} // DaReaderWriterIoUnitTests::testReadIntFromLine
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void DaReaderWriterIoUnitTests::testReadStringFromLine()
{
  // read from front
  std::string stringValue;
  std::string line = "value1 value2 3";
  TS_ASSERT(DaStreamReader::ReadStringFromLine(line, stringValue));
  TS_ASSERT_EQUALS("value1", stringValue);
  TS_ASSERT_EQUALS(" value2 3", line);

  // read second value (with a space)
  line = " value2 value3";
  TS_ASSERT(DaStreamReader::ReadStringFromLine(line, stringValue));
  TS_ASSERT_EQUALS("value2", stringValue);
  TS_ASSERT_EQUALS(" value3", line);

  // read last value
  line = "3";
  TS_ASSERT(DaStreamReader::ReadStringFromLine(line, stringValue));
  TS_ASSERT_EQUALS("3", stringValue);
  TS_ASSERT_EQUALS("", line);

  // fails with empty line (string value stays the same)
  line = "";
  stringValue = "3";
  TS_ASSERT(!DaStreamReader::ReadStringFromLine(line, stringValue));
  TS_ASSERT_EQUALS("3", stringValue);
  TS_ASSERT_EQUALS("", line);
} // DaReaderWriterIoUnitTests::testReadStringFromLine
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void DaReaderWriterIoUnitTests::testReadDoubleFromLine()
{
  // read from front
  double doubleValue;
  std::string line = "1.1 -1.0e-3 3";
  TS_ASSERT(DaStreamReader::ReadDoubleFromLine(line, doubleValue));
  TS_ASSERT_EQUALS(1.1, doubleValue);
  TS_ASSERT_EQUALS(" -1.0e-3 3", line);

  // read second value (with a space)
  line = " -1.0e-3 3";
  TS_ASSERT(DaStreamReader::ReadDoubleFromLine(line, doubleValue));
  TS_ASSERT_EQUALS(-1.0e-3, doubleValue);
  TS_ASSERT_EQUALS(" 3", line);

  // read last value
  line = "3";
  TS_ASSERT(DaStreamReader::ReadDoubleFromLine(line, doubleValue));
  TS_ASSERT_EQUALS(3, doubleValue);
  TS_ASSERT_EQUALS("", line);

  // fails with empty line (string value stays the same)
  line = "";
  doubleValue = 3;
  TS_ASSERT(!DaStreamReader::ReadDoubleFromLine(line, doubleValue));
  TS_ASSERT_EQUALS(3, doubleValue);
  TS_ASSERT_EQUALS("", line);
} // DaReaderWriterIoUnitTests::testReadDoubleFromLine
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void DaReaderWriterIoUnitTests::testReadWriteIntLine()
{
  std::ostringstream outputStream;
  DaStreamWriter writer(outputStream);
  const char* name = "LINE_NAME";
  const int expect = 22;
  writer.WriteIntLine(name, expect);
  std::string outputExpected = "LINE_NAME 22\n";
  std::string outputFound = outputStream.str();
  TS_ASSERT_EQUALS(outputExpected, outputFound);

  std::istringstream inputStream(outputStream.str());
  DaStreamReader reader(inputStream);
  int found;
  TS_ASSERT(reader.ReadIntLine(name, found));
  TS_ASSERT_EQUALS(expect, found);
} // DaReaderWriterIoUnitTests::testReadWriteIntLine
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void DaReaderWriterIoUnitTests::testReadWriteDoubleLine()
{
  std::ostringstream outputStream;
  DaStreamWriter writer(outputStream);
  const char* name = "LINE_NAME";
  const double expect = 22.1;
  writer.WriteDoubleLine(name, expect);
  std::string outputExpected = "LINE_NAME 22.1\n";
  std::string outputFound = outputStream.str();
  TS_ASSERT_EQUALS(outputExpected, outputFound);

  std::istringstream inputStream(outputStream.str());
  DaStreamReader reader(inputStream);
  double found;
  TS_ASSERT(reader.ReadDoubleLine(name, found));
  TS_ASSERT_EQUALS(expect, found);
} // DaReaderWriterIoUnitTests::testReadWriteDoubleLine
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void DaReaderWriterIoUnitTests::testReadWrite3DoubleLine()
{
  std::ostringstream outputStream;
  DaStreamWriter writer(outputStream);
  const char* name = "LINE_NAME";
  const double expect1 = 22.1;
  const double expect2 = 22.2;
  const double expect3 = 22.3;
  writer.Write3DoubleLine(name, expect1, expect2, expect3);
  std::string outputExpected = "LINE_NAME 22.1 22.2 22.3\n";
  std::string outputFound = outputStream.str();
  TS_ASSERT_EQUALS(outputExpected, outputFound);

  std::istringstream inputStream(outputStream.str());
  DaStreamReader reader(inputStream);
  double found1;
  double found2;
  double found3;
  TS_ASSERT(reader.Read3DoubleLine(name, found1, found2, found3));
  TS_ASSERT_EQUALS(expect1, found1);
  TS_ASSERT_EQUALS(expect2, found2);
  TS_ASSERT_EQUALS(expect3, found3);
} // DaReaderWriterIoUnitTests::testReadWrite3DoubleLine
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void DaReaderWriterIoUnitTests::testReadWriteVecInt()
{
  std::ostringstream outputStream;
  DaStreamWriter writer(outputStream);
  const char* name = "VECTOR_NAME";
  const VecInt expect = {1, 2, 3};
  writer.WriteVecInt(name, expect);
  std::string outputExpected =
    "VECTOR_NAME 3\n"
    "  1\n"
    "  2\n"
    "  3\n";
  std::string outputFound = outputStream.str();
  TS_ASSERT_EQUALS(outputExpected, outputFound);

  std::istringstream inputStream(outputStream.str());
  DaStreamReader reader(inputStream);
  VecInt found;
  TS_ASSERT(reader.ReadVecInt(name, found));
  TS_ASSERT_EQUALS(expect, found);
} // DaReaderWriterIoUnitTests::testReadWriteVecInt
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void DaReaderWriterIoUnitTests::testReadWriteVecDbl()
{
  std::ostringstream outputStream;
  DaStreamWriter writer(outputStream);
  const char* name = "VECTOR_NAME";
  const VecDbl expect = {1.1, 2.2, 3.3};
  writer.WriteVecDbl(name, expect);
  std::string outputExpected =
    "VECTOR_NAME 3\n"
    "  1.1\n"
    "  2.2\n"
    "  3.3\n";
  std::string outputFound = outputStream.str();
  TS_ASSERT_EQUALS(outputExpected, outputFound);

  std::istringstream inputStream(outputStream.str());
  DaStreamReader reader(inputStream);
  VecDbl found;
  TS_ASSERT(reader.ReadVecDbl(name, found));
  TS_ASSERT_EQUALS(expect, found);
} // DaReaderWriterIoUnitTests::testReadWriteVecDbl
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void DaReaderWriterIoUnitTests::testReadWriteVecPt3d()
{
  std::ostringstream outputStream;
  DaStreamWriter writer(outputStream);
  const char* name = "VECTOR_NAME";
  const VecPt3d expect = {
    {1.1, 1.2, 1.3},
    {2.1, 2.2, 2.3},
  };
  writer.WriteVecPt3d(name, expect);
  std::string outputExpected =
    "VECTOR_NAME 2\n"
    "  POINT 0 1.1 1.2 1.3\n"
    "  POINT 1 2.1 2.2 2.3\n";
  std::string outputFound = outputStream.str();
  TS_ASSERT_EQUALS(outputExpected, outputFound);

  std::istringstream inputStream(outputStream.str());
  DaStreamReader reader(inputStream);
  VecPt3d found;
  TS_ASSERT(reader.ReadVecPt3d(name, found));
  TS_ASSERT_EQUALS(expect, found);
} // DaReaderWriterIoUnitTests::testReadWriteVecPt3d
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void DaReaderWriterIoUnitTests::testReadWriteBinaryVecInt()
{
  std::ostringstream outputStream;
  bool useBinaryArrays = true;
  DaStreamWriter writer(outputStream, useBinaryArrays);
  const char* name = "VECTOR_NAME";
  VecInt expect(100);
  std::iota(expect.begin(), expect.end(), 0);
  writer.WriteVecInt(name, expect);

  std::istringstream inputStream(outputStream.str());
  DaStreamReader reader(inputStream, useBinaryArrays);
  VecInt found;
  TS_ASSERT(reader.ReadVecInt(name, found));
  TS_ASSERT_EQUALS(expect, found);
} // DaReaderWriterIoUnitTests::testReadWriteBinaryVecInt
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void DaReaderWriterIoUnitTests::testReadWriteBinaryVecDbl()
{
  std::ostringstream outputStream;
  bool useBinaryArrays = true;
  DaStreamWriter writer(outputStream, useBinaryArrays);
  const char* name = "VECTOR_NAME";
  VecDbl expect(100);
  int count = 0;
  for (auto& e : expect)
    e = ++count;
  writer.WriteVecDbl(name, expect);

  std::istringstream inputStream(outputStream.str());
  DaStreamReader reader(inputStream, useBinaryArrays);
  VecDbl found;
  TS_ASSERT(reader.ReadVecDbl(name, found));
  TS_ASSERT_EQUALS(expect, found);
} // DaReaderWriterIoUnitTests::testReadWriteBinaryVecDbl
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void DaReaderWriterIoUnitTests::testReadWriteBinaryVecPt3d()
{
  std::ostringstream outputStream;
  bool useBinaryArrays = true;
  DaStreamWriter writer(outputStream, useBinaryArrays);
  const char* name = "VECTOR_NAME";
  VecPt3d expect(100);
  int count = 0;
  for (auto& e : expect)
  {
    e = Pt3d(count, count + 1, count + 2);
    ++count;
  }
  writer.WriteVecPt3d(name, expect);

  std::istringstream inputStream(outputStream.str());
  DaStreamReader reader(inputStream, useBinaryArrays);
  VecPt3d found;
  TS_ASSERT(reader.ReadVecPt3d(name, found));
  TS_ASSERT_EQUALS(expect, found);
} // DaReaderWriterIoUnitTests::testReadWriteBinaryVecPt3d
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void DaReaderWriterIoUnitTests::testReadWriteLineParts()
{
  std::ostringstream outputStream;
  DaStreamWriter writer(outputStream);
  writer.WriteString("STRING_ONE");
  TS_ASSERT_EQUALS("STRING_ONE", outputStream.str());
  writer.AppendInt(0);
  TS_ASSERT_EQUALS("STRING_ONE 0", outputStream.str());
  writer.AppendString("STRING_TWO");
  TS_ASSERT_EQUALS("STRING_ONE 0 STRING_TWO", outputStream.str());
  int ints[] = {1, 2, 3};
  writer.AppendInts(ints, 3);
  TS_ASSERT_EQUALS("STRING_ONE 0 STRING_TWO 1 2 3", outputStream.str());
  writer.EndLine();
  TS_ASSERT_EQUALS("STRING_ONE 0 STRING_TWO 1 2 3\n", outputStream.str());

  std::istringstream inputStream("STRING_ONE 0\n1 STRING_TWO");
  DaStreamReader reader(inputStream);
  std::string s;
  int i;
  TS_ASSERT(reader.ReadString(s));
  TS_ASSERT_EQUALS("STRING_ONE", s)
  TS_ASSERT(reader.ReadInt(i));
  TS_ASSERT_EQUALS(0, i);
  TS_ASSERT(reader.NextLine());

  TS_ASSERT(reader.ReadInt(i));
  TS_ASSERT_EQUALS(1, i);
  TS_ASSERT(reader.ReadString(s));
  TS_ASSERT_EQUALS("STRING_TWO", s)
  TS_ASSERT(!reader.NextLine());
} // DaReaderWriterIoUnitTests::testReadWriteLineParts
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void DaReaderWriterIoUnitTests::testReadWriteBinaryArrays()
{
  VecInt outValues(500);
  std::iota(outValues.begin(), outValues.end(), 0);
  long long lengthInBytes = (long long)outValues.size() * sizeof(VecInt::value_type);
  std::ostringstream output;
  DaStreamWriter writer(output);
  writer.SetBinaryBlockSize(120);
  writer.WriteBinaryBytes((char*)&outValues[0], lengthInBytes);
  std::string text = output.str();
  std::string expectedText =
    "BINARY_BLOCK 74 120\n"
    "eAENw4UNwDAAAKDO3d3+f3OQEEIIkbGJqZm5haWVtY2tnb2Do5Ozi6ubu4enl7ePr58/RrQBtA\n"
    "BINARY_BLOCK 78 120\n"
    "eAENw4UNwzAAALBcUuaVGf7/a7bkKIQQm5iamVtYWlnb2Nr5s3dwdHJ2cXVz9/D08vbx9fMPILsFOA\n"
    "BINARY_BLOCK 78 120\n"
    "eAENw4UNwzAAALAcVuaVGf5/ZLbkKIQQm5iamVtYWlnb2Nr5s3dwdHJ2cXVz9/D08vbx9fMP+rMIvA\n"
    "BINARY_BLOCK 76 120\n"
    "eAENw4UNwzAAALDcWeaVGd6fLTkKIcQmpmbmFpZW1ja2dv7sHRydnF1c3dw9PL28fXz9/APUugxA\n"
    "BINARY_BLOCK 76 120\n"
    "eAENw4UNwzAAALCcXeaVGf6dLTkKIcQmpmbmFpZW1ja2dv7sHRydnF1c3dw9PL28fXz9/AOuwQ/E\n"
    "BINARY_BLOCK 78 120\n"
    "eAENw4UNwzAAALD8f0CZV2Z4cLbkKIQQm5iamVtYWlnb2Nr5s3dwdHJ2cXVz9/D08vbx9fMPiMgTSA\n"
    "BINARY_BLOCK 78 120\n"
    "eAENw4UNwzAAALD8f0+ZV2b4aLbkKIQQm5iamVtYWlnb2Nr5s3dwdHJ2cXVz9/D08vbx9fMPYs8WzA\n"
    "BINARY_BLOCK 78 120\n"
    "eAENw4UNwzAAALD8f16ZV2Z4YbbkKIQQm5iamVtYWlnb2Nr5s3dwdHJ2cXVz9/D08vbx9fMPPNYaUA\n"
    "BINARY_BLOCK 74 120\n"
    "eAENw4UNwDAAAKDO/f83524k0IcQBkcnZxdXN3cPTy9vH18/Q4SxiamZuYWllbWNrZ0/dFUP4g\n"
    "BINARY_BLOCK 82 120\n"
    "eAENw4URg0AAALBnAbRIkeJS2H8/krvEUQiJqZm5hR9LK2sbv7Z29g7+HJ2cXVzd3D08vfx7+/gCs5IDdg\n"
    "BINARY_BLOCK 82 120\n"
    "eAENw4URg0AAALBnH7RIkeJS2H8hkrvEUQiJqZm5hR9LK2sbv7Z29g7+HJ2cXVzd3D08vfx7+/gCjZkG+g\n"
    "BINARY_BLOCK 82 120\n"
    "eAENw4URg0AAALBnPbRIkeJS2H8DkrvEUQiJqZm5hR9LK2sbv7Z29g7+HJ2cXVzd3D08vfx7+/gCZ6AKfg\n"
    "BINARY_BLOCK 79 120\n"
    "eAENwwUOg0AAALDjt+iQIcNl8G/apHEUQmJqZm7hx9LK2savrZ29gz9HJ2cXVzd3D08v/94+vkGnDgI\n"
    "BINARY_BLOCK 79 120\n"
    "eAENwwUOg0AAALDj8+iQIcNl8FHapHEUQmJqZm7hx9LK2savrZ29gz9HJ2cXVzd3D08v/94+vhuuEYY\n"
    "BINARY_BLOCK 82 120\n"
    "eAENw4URg0AAALBn/zXQIkWKS2EzkrvEUQiJqZm5hR9LK2sbv7Z29g7+HJ2cXVzd3D08vfx7+/gC9aYVCg\n"
    "BINARY_BLOCK 82 120\n"
    "eAENw4URg0AAALBn/63QIkWKS2EVkrvEUQiJqZm5hR9LK2sbv7Z29g7+HJ2cXVzd3D08vfx7+/gCz60Yjg\n"
    "BINARY_BLOCK 63 80\n"
    "eAENwwESQCAAALD8/5NEkUj0Advd5imExejqZjK7e1g8rV7eNh+7r5/DH/dqElM\n";
  TS_ASSERT_EQUALS(expectedText, text);

  std::istringstream input(expectedText);
  DaStreamReader reader(input);
  VecInt inValues(500);
  TS_ASSERT(reader.ReadBinaryBytes((char*)&inValues[0], lengthInBytes));
  TS_ASSERT_EQUALS(outValues, inValues);
} // DaReaderWriterIoUnitTests::testReadWriteBinaryArrays
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void DaReaderWriterIoUnitTests::testLineBeginsWith()
{
  const char* inputText =
    "VECTOR_NAME 2\n"
    "  POINT 0 1.1 1.2 1.3\n"
    "  POINT 1 2.1 2.2 2.3\n";
  std::istringstream inputStream(inputText);
  DaStreamReader reader(inputStream);
  TS_ASSERT(reader.LineBeginsWith("VECTOR_NAME"));
  std::string line;
  TS_ASSERT(reader.ReadLine(line));
  TS_ASSERT_EQUALS("VECTOR_NAME 2", line);
  TS_ASSERT(reader.LineBeginsWith("  POINT"));
  TS_ASSERT(reader.ReadLine(line));
  TS_ASSERT_EQUALS("  POINT 0 1.1 1.2 1.3", line);
  TS_ASSERT(reader.LineBeginsWith("  POINT 1 2.1 2.2 2.3"));
  TS_ASSERT(reader.ReadLine(line));
  TS_ASSERT_EQUALS("  POINT 1 2.1 2.2 2.3", line);
} // DaReaderWriterIoUnitTests::testLineBeginsWith

#endif