DataStream.cc

Go to the documentation of this file.

#if 0
/*
 * (C) Copyright 1996-2012 ECMWF.
 * 
 * This software is licensed under the terms of the Apache Licence Version 2.0
 * which can be obtained at http://www.apache.org/licenses/LICENSE-2.0. 
 * In applying this licence, ECMWF does not waive the privileges and immunities 
 * granted to it by virtue of its status as an intergovernmental organisation nor
 * does it submit to any jurisdiction.
 */
 
///
/// \file DataStream.cc
///
/// @author Piotr Kuchta, March 2009
 
#include "eckit/exception/Exceptions.h"
#include "eckit/io/DataHandle.h"
#include "eckit/io/Length.h"
#include "eckit/log/CodeLocation.h"
 
namespace odc {
 
// Can't use eckti::DataHandle&, as Currently "NonVirtual" is the baseclass of
// UnsafeInMemoryDataHandle... Wonderful...
template <typename DH>
inline void checkRead(int code, const char *msg, const DH& dh, const eckit::CodeLocation& loc)
{
    if(code != 0)
    {
        std::stringstream ss;
        ss << "DatStream(" << dh << ") failed check: " << msg;
        throw eckit::ReadError(ss.str(), loc);
    }
}
 
#define CHECK_READ(d, a) \
{ \
    long _v; \
    if (!(_v = (a))) { \
        ::odc::checkRead(_v, #a, d, Here()); \
    } \
}
 
template <typename T, typename D>
DataStream<T,D>::DataStream() : f() {}
 
template <typename T, typename D>
DataStream<T,D>::DataStream(D *dh) : f(dh) {}
 
template <typename T, typename D>
DataStream<T,D>::DataStream(D &dh) : f(&dh) {}
 
template <typename T, typename D>
void DataStream<T,D>::close() { f->close(); }
 
template <typename T, typename D>
long DataStream<T,D>::read(void* p, long l) { return f->read(p, l);
}
 
template <typename T, typename D>
void DataStream<T,D>::readInt32(int32_t& i)
{
    CHECK_READ(*f, f->read(&i, sizeof(int32_t)) == sizeof(int32_t));
    T::swap(i);
}
 
template <typename T, typename D>
void DataStream<T,D>::readInt64(int64_t& i)
{
    CHECK_READ(*f, f->read(&i, sizeof(int64_t)) == sizeof(int64_t));
    T::swap(i);
}
 
template <typename T, typename D>
void DataStream<T,D>::writeInt32(int32_t i)
{
    T::swap(i);
    ASSERT(f->write(&i, sizeof(int32_t)) == sizeof(int32_t));
}
 
template <typename T, typename D>
void DataStream<T,D>::writeInt64(int64_t i)
{
    T::swap(i);
    ASSERT(f->write(&i, sizeof(int64_t)) == sizeof(int64_t));
}
 
template <typename T, typename D>
void DataStream<T,D>::readInt16(int16_t& i)
{
    CHECK_READ(*f, f->read(&i, sizeof(int16_t)) == sizeof(int16_t));
    T::swap(i);
}
 
template <typename T, typename D>
void DataStream<T,D>::writeInt16(int16_t i)
{
    T::swap(i);
    ASSERT(f->write(&i, sizeof(int16_t)) == sizeof(int16_t));
}
 
template <typename T, typename D>
void DataStream<T,D>::readUInt16(uint16_t& i)
{
    CHECK_READ(*f, f->read(&i, sizeof(uint16_t)) == sizeof(uint16_t));
    T::swap(i);
}
 
template <typename T, typename D>
void DataStream<T,D>::writeUInt16(uint16_t i)
{
    T::swap(i);
    ASSERT(f->write(&i, sizeof(uint16_t)) == sizeof(uint16_t));
}
 
template <typename T, typename D>
void DataStream<T,D>::readBuffer(MemoryBlock &buffer)
{
    int32_t size;
    readInt32(size);
    buffer.size(size);
    CHECK_READ(*f, f->read(buffer, size) == size);
}
 
template <typename T, typename D>
void DataStream<T,D>::writeBuffer(const MemoryBlock &buffer)
{
    writeInt32(buffer.size());
    eckit::Length writtenBytes = f->write(buffer, buffer.size());
    ASSERT(long (writtenBytes) == long (buffer.size()));
}
 
template <typename T, typename D>
void DataStream<T,D>::readString(std::string &s)
{
    int32_t len;
    readInt32(len);
 
#ifdef _HPUX_SOURCE
    char buff[8 * 1024 * 1024];
    ASSERT(len < sizeof(buff));
#else
    char buff[len];
#endif
    CHECK_READ(*f, f->read(&buff, len) == len);
    
    std::string r(buff, len);
 
    s = r;
}
 
template <typename T, typename D>
void DataStream<T,D>::writeString(const std::string &s)
{
    int32_t len = s.size();
    writeInt32(len);
    ASSERT(f->write(s.c_str(), len) == len);
}
 
template <typename T, typename D>
void DataStream<T,D>::readChar(char &c)
{
    CHECK_READ(*f, f->read(&c, sizeof(char)) == sizeof(char));
}
 
template <typename T, typename D>
void DataStream<T,D>::writeChar(char c)
{
    size_t n = f->write(&c, sizeof(char));
    ASSERT(n == sizeof(char));
}
 
template <typename T, typename D>
void DataStream<T,D>::readUChar(unsigned char &c)
{
    size_t n = f->read(&c, sizeof(unsigned char));
    ASSERT(n == sizeof(unsigned char));
}
 
template <typename T, typename D>
void DataStream<T,D>::writeUChar(const unsigned char c)
{
    ASSERT(f->write(&c, sizeof(unsigned char)) == sizeof(unsigned char));
}
 
template <typename T, typename D>
void DataStream<T,D>::readBytes(char *buff, size_t &len)
{
    CHECK_READ(*f, f->read(buff, len) == static_cast<long>(len));
}
 
template <typename T, typename D>
void DataStream<T,D>::writeBytes(const char *buff, size_t len)
{
    ASSERT(f->write(buff, len) == static_cast<long>(len));
}
 
template <typename T, typename D>
void DataStream<T,D>::readDouble(double &d)
{
    CHECK_READ(*f, f->read(&d, sizeof(double)) == sizeof(double));
    T::swap(d);
}
 
template <typename T, typename D>
void DataStream<T,D>::writeDouble(double d)
{
    T::swap(d);
    ASSERT(f->write(&d, sizeof(double)) == sizeof(double));
}
 
template <typename T, typename D>
void DataStream<T,D>::readFloat(float &d)
{
    CHECK_READ(*f, f->read(&d, sizeof(float)) == sizeof(float));
    T::swap(d);
}
 
template <typename T, typename D>
void DataStream<T,D>::writeFloat(float d)
{
    T::swap(d);
    ASSERT(f->write(&d, sizeof(float)) == sizeof(float));
}
 
template <typename T, typename D>
void DataStream<T,D>::readProperties(Properties &p)
{
    int32_t size = 0;
    readInt32(size);
 
    for (int i = 0; i < size; i++)
    {
        std::string key, value;
        readString(key);
        readString(value);
        p[key] = value;
    }
}
 
template <typename T, typename D>
void DataStream<T,D>::writeProperties(const Properties &p)
{
    int32_t size = p.size();
    writeInt32(size);
 
    for(Properties::const_iterator i = p.begin(); i != p.end(); ++i)
    {
        writeString(i->first);
        writeString(i->second);
    }
}
 
template <typename T, typename D>
void DataStream<T,D>::readFlags(Flags &v)
{
    int32_t size = 0;
    readInt32(size);
 
    v.clear();
    v.resize(size);
 
    for (int32_t i = 0; i < size; ++i)
        readDouble(v[i]);
}
 
template <typename T, typename D>
void DataStream<T,D>::writeFlags(const Flags &v)
{
    int32_t size = v.size();
    writeInt32(size);
 
    for (int32_t i = 0; i < size; ++i)
        writeDouble(v[i]);
}
 
template <typename T, typename D>
void DataStream<T,D>::readBitfieldDef(eckit::sql::BitfieldDef &v)
{
    eckit::sql::FieldNames& names = v.first;
    eckit::sql::Sizes& sizes = v.second;
    
    names.clear();
    sizes.clear();
 
    int32_t namesSize = 0;
    readInt32(namesSize);
 
    for (int32_t i = 0; i < namesSize; i++)
    {
        std::string s;
        readString(s);
        names.push_back(s);
    }
 
    int32_t sizesSize = 0;
    readInt32(sizesSize);
 
    ASSERT(namesSize == sizesSize);
 
    for (int32_t i = 0; i < sizesSize; i++)
    {
        int32_t n;
        readInt32(n);
        sizes.push_back(n);
    }
}
 
template <typename T, typename D>
void DataStream<T,D>::writeBitfieldDef(const eckit::sql::BitfieldDef &v)
{
    const eckit::sql::FieldNames& names = v.first;
    const eckit::sql::Sizes& sizes = v.second;
 
    writeInt32(names.size());
    for (size_t i = 0; i < names.size(); i++)
        writeString(names[i]);
 
    writeInt32(sizes.size());
    for (size_t i = 0; i < sizes.size(); i++)
        writeInt32(sizes[i]);
}
 
#undef CHECK_READ
 
} // namespace odc
 
 
#endif