DataStream.h

// Copyright (c) 2013 by István Váradi
 
// This file is part of VSCPL, a simple cross-platform utility library
 
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are met:
 
// 1. Redistributions of source code must retain the above copyright notice, this
//    list of conditions and the following disclaimer.
// 2. Redistributions in binary form must reproduce the above copyright notice,
//    this list of conditions and the following disclaimer in the documentation
//    and/or other materials provided with the distribution.
 
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
// ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
// (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
// LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
// ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
// The views and conclusions contained in the software and documentation are those
// of the authors and should not be interpreted as representing official policies,
// either expressed or implied, of the FreeBSD Project.
 
#ifndef HU_VARADIISTVAN_SCPL_IO_DATASTREAM_H
#define HU_VARADIISTVAN_SCPL_IO_DATASTREAM_H
//------------------------------------------------------------------------------
 
#include "BlockingStream.h"
 
#include <string>
 
#include <cstring>
 
#include <inttypes.h>
 
//------------------------------------------------------------------------------
 
namespace hu { namespace varadiistvan { namespace scpl { namespace io {
 
//------------------------------------------------------------------------------
 
class DataStream : public BlockingStream
{
public:
    DataStream(BufferedStream& stream);
 
    template <typename T> T readT(T defaultValue = 0);
 
    int8_t readS8();
 
    uint8_t readU8();
 
    int16_t readS16();
 
    uint16_t readU16();
 
    int32_t readS32();
 
    uint32_t readU32();
 
    int64_t readS64();
 
    uint64_t readU64();
 
    float readFloat();
 
    double readDouble();
 
    long double readLongDouble();
 
    size_t readLength();
 
    std::string readString();
 
    size_t readString(char* dest, size_t capacity);
 
    bool writeS8(int8_t x);
 
    bool writeU8(uint8_t x);
 
    bool writeS16(int16_t x);
 
    bool writeU16(uint16_t x);
 
    bool writeS32(int32_t x);
 
    bool writeU32(uint32_t x);
 
    bool writeS64(int64_t x);
 
    bool writeU64(uint64_t x);
 
    bool writeFloat(float x);
 
    bool writeDouble(double x);
 
    bool writeLongDouble(long double x);
 
    bool writeLength(size_t length);
 
    bool writeString(const char* s, size_t length);
 
    bool writeString(const std::string& s);
 
    bool writeString(const char* s);
};
 
//------------------------------------------------------------------------------
// Inline definitions
//------------------------------------------------------------------------------
 
inline DataStream::DataStream(BufferedStream& stream) :
    BlockingStream(stream)
{
}
 
//------------------------------------------------------------------------------
 
template <typename T> T DataStream::readT(T defaultValue)
{
    T value = defaultValue;
    read(&value, sizeof(value));
    return value;
}
 
//------------------------------------------------------------------------------
 
inline int8_t DataStream::readS8()
{
    return readT<int8_t>(0);
}
 
//------------------------------------------------------------------------------
 
inline uint8_t DataStream::readU8()
{
    return readT<uint8_t>(0);
}
 
//------------------------------------------------------------------------------
 
inline int16_t DataStream::readS16()
{
    return readT<int16_t>(0);
}
 
//------------------------------------------------------------------------------
 
inline uint16_t DataStream::readU16()
{
    return readT<uint16_t>(0);
}
 
//------------------------------------------------------------------------------
 
inline int32_t DataStream::readS32()
{
    return readT<int32_t>(0);
}
 
//------------------------------------------------------------------------------
 
inline uint32_t DataStream::readU32()
{
    return readT<uint32_t>(0);
}
 
//------------------------------------------------------------------------------
 
inline int64_t DataStream::readS64()
{
    return readT<int64_t>(0);
}
 
//------------------------------------------------------------------------------
 
inline uint64_t DataStream::readU64()
{
    return readT<uint64_t>(0);
}
 
//------------------------------------------------------------------------------
 
inline float DataStream::readFloat()
{
    return readT<float>(0.0);
}
 
//------------------------------------------------------------------------------
 
inline double DataStream::readDouble()
{
    return readT<double>(0.0);
}
 
//------------------------------------------------------------------------------
 
inline long double DataStream::readLongDouble()
{
    return readT<long double>(0.0);
}
 
//------------------------------------------------------------------------------
 
inline bool DataStream::writeS8(int8_t x)
{
    return write(&x, sizeof(x));
}
 
//------------------------------------------------------------------------------
 
inline bool DataStream::writeU8(uint8_t x)
{
    return write(&x, sizeof(x));
}
 
//------------------------------------------------------------------------------
 
inline bool DataStream::writeS16(int16_t x)
{
    return write(&x, sizeof(x));
}
 
//------------------------------------------------------------------------------
 
inline bool DataStream::writeU16(uint16_t x)
{
    return write(&x, sizeof(x));
}
 
//------------------------------------------------------------------------------
 
inline bool DataStream::writeS32(int32_t x)
{
    return write(&x, sizeof(x));
}
 
//------------------------------------------------------------------------------
 
inline bool DataStream::writeU32(uint32_t x)
{
    return write(&x, sizeof(x));
}
 
//------------------------------------------------------------------------------
 
inline bool DataStream::writeS64(int64_t x)
{
    return write(&x, sizeof(x));
}
 
//------------------------------------------------------------------------------
 
inline bool DataStream::writeU64(uint64_t x)
{
    return write(&x, sizeof(x));
}
 
//------------------------------------------------------------------------------
 
inline bool DataStream::writeFloat(float x)
{
    return write(&x, sizeof(x));
}
 
//------------------------------------------------------------------------------
 
inline bool DataStream::writeDouble(double x)
{
    return write(&x, sizeof(x));
}
 
//------------------------------------------------------------------------------
 
inline bool DataStream::writeLongDouble(long double x)
{
    return write(&x, sizeof(x));
}
 
//------------------------------------------------------------------------------
 
inline bool DataStream::writeString(const char* s, size_t length)
{
    if (!writeLength(length)) return false;
    else return write(s, length);
}
 
//------------------------------------------------------------------------------
 
inline bool DataStream::writeString(const std::string& s)
{
    return writeString(s.c_str(), s.length());
}
 
//------------------------------------------------------------------------------
 
inline bool DataStream::writeString(const char* s)
{
    return writeString(s, strlen(s));
}
 
//------------------------------------------------------------------------------
 
} /* namespace hu::varadiistvan::scpl::io */ } /* namespace hu::varadiistvan::scpl */ } /* namespace hu::varadiistvan */ } /* namespace hu */
 
//------------------------------------------------------------------------------
#endif // HU_VARADIISTVAN_SCPL_IO_DATASTREAM_H
 
// Local Variables:
// mode: C++
// c-basic-offset: 4
// indent-tabs-mode: nil
// End: