binary_stream.cpp

/*---------------------------------------------------------------------------*\
 *
 *  bitpit
 *
 *  Copyright (C) 2015-2021 OPTIMAD engineering Srl
 *
 *  -------------------------------------------------------------------------
 *  License
 *  This file is part of bitpit.
 *
 *  bitpit is free software: you can redistribute it and/or modify it
 *  under the terms of the GNU Lesser General Public License v3 (LGPL)
 *  as published by the Free Software Foundation.
 *
 *  bitpit is distributed in the hope that it will be useful, but WITHOUT
 *  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 *  FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
 *  License for more details.
 *
 *  You should have received a copy of the GNU Lesser General Public License
 *  along with bitpit. If not, see <http://www.gnu.org/licenses/>.
 *
\*---------------------------------------------------------------------------*/
 
#include <cassert>
#include <limits>
#include <cmath>
#include <cstring>
 
#include "binary_stream.hpp"
 
namespace bitpit {
 
template<>
bitpit::IBinaryStream& operator>>(bitpit::IBinaryStream &stream, std::string &data)
{
    std::size_t size;
    stream.read(reinterpret_cast<char *>(&size), sizeof(size));
 
    if (size > 0) {
        std::vector<char> buffer(size);
        stream.read(buffer.data(), size);
        data.assign(buffer.data(), size);
    } else {
        data = "";
    }
 
    return stream;
}
 
template<>
bitpit::OBinaryStream& operator<<(bitpit::OBinaryStream &stream, const std::string &data)
{
    std::size_t size = data.size();
    stream.write(reinterpret_cast<const char *>(&size), sizeof(size));
 
    if (size > 0) {
        stream.write(data.c_str(), size);
    }
 
    return stream;
}
 
BinaryStream::BinaryStream()
    : m_size(0), m_pos(0), m_chunkSize(1)
{
}
 
BinaryStream::BinaryStream(std::size_t size)
    : m_pos(0)
{
    setSize(size);
}
 
BinaryStream::BinaryStream(const char *buffer, std::size_t capacity)
{
    open(buffer, capacity);
}
 
BinaryStream::BinaryStream(const std::vector<char> &buffer)
{
    open(buffer.data(), buffer.size());
}
 
void BinaryStream::open(const char *buffer, std::size_t size)
{
    open(size);
 
    m_buffer.assign(buffer, buffer + size);
}
 
void BinaryStream::open(std::size_t size)
{
    m_pos = 0;
 
    setSize(size);
}
 
std::streampos BinaryStream::tellg() const
{
    return m_pos;
}
 
bool BinaryStream::seekg(std::size_t pos)
{
    if (pos >= getSize()) {
        return false;
    }
 
    m_pos = pos;
 
    return true;
}
 
char * BinaryStream::data()
{
    return m_buffer.data();
}
 
const char * BinaryStream::data() const
{
    return m_buffer.data();
}
 
bool BinaryStream::eof() const
{
    return (m_pos >= getSize());
}
 
bool BinaryStream::seekg(std::streamoff offset, std::ios_base::seekdir way)
{
    if ((way == std::ios_base::beg) && (offset < (long) getSize())) {
        m_pos = offset;
    } else if ((way == std::ios_base::cur) && (m_pos + offset < getSize())) {
        m_pos += offset;
    } else if ((way == std::ios_base::end) && ((long) getSize() - offset >= 0)) {
        m_pos = getSize() - offset;
    } else {
        return false;
    }
 
    return true;
}
 
std::size_t BinaryStream::getSize() const
{
    return m_size;
}
 
void BinaryStream::setSize(std::size_t size)
{
    setCapacity(size);
 
    m_size = size;
}
 
void BinaryStream::setCapacity(std::size_t capacity)
{
    m_chunkSize = 1;
    std::size_t nChunks = capacity;
    while (nChunks > (std::size_t) std::numeric_limits<int>::max()) {
        m_chunkSize = 2 * m_chunkSize;
        nChunks     = (1 + ((capacity - 1) / m_chunkSize));
    }
 
    m_buffer.resize(nChunks * m_chunkSize);
}
 
int BinaryStream::getChunkSize()
{
    return m_chunkSize;
}
 
int BinaryStream::getChunkCount()
{
    return (getCapacity() / m_chunkSize);
}
 
std::size_t BinaryStream::getCapacity() const
{
    return m_buffer.size();
}
 
IBinaryStream::IBinaryStream()
    : BinaryStream()
{
}
 
IBinaryStream::IBinaryStream(std::size_t size)
    : BinaryStream(size)
{
}
 
IBinaryStream::IBinaryStream(const char *buffer, std::size_t size)
    : BinaryStream(buffer, size)
{
}
 
IBinaryStream::IBinaryStream(const std::vector<char> &buffer)
    : BinaryStream(buffer)
{
}
 
void IBinaryStream::open(std::size_t size)
{
    BinaryStream::open(size);
}
 
void IBinaryStream::open(const char *buffer, std::size_t size)
{
    BinaryStream::open(buffer, size);
}
 
void IBinaryStream::read(char *data, std::size_t size)
{
    if ((m_pos + size) > getSize()) {
        throw std::runtime_error("Bad memory access!");
    }
 
    std::memcpy(data, m_buffer.data() + m_pos, size);
    m_pos += size;
}
 
OBinaryStream::OBinaryStream()
    : BinaryStream(), m_expandable(true)
{
}
 
OBinaryStream::OBinaryStream(std::size_t size)
    : BinaryStream(size), m_expandable(size == 0)
{
}
 
void OBinaryStream::open(std::size_t size)
{
    // Set the stream expandable to allow changing its size
    m_expandable = true;
 
    // Open a stream with the desidered size
    BinaryStream::open(size);
 
    // Set the definitive expandable flag
    m_expandable = (size == 0);
}
 
void OBinaryStream::setSize(std::size_t size)
{
    if (!m_expandable) {
        throw std::runtime_error("Stream is not expandable.");
    }
 
    BinaryStream::setSize(size);
}
 
void OBinaryStream::squeeze()
{
    bool expandableFlag = m_expandable;
 
    // Set the stream expandable to allow changing its size
    m_expandable = true;
 
    // Update the size of the stream
    setSize(tellg());
 
    // Set the expandable flag back to its initial value
    m_expandable = expandableFlag;
}
 
void OBinaryStream::write(const char *data, std::size_t size)
{
    if (getSize() - m_pos < size) {
        // If the stream is not expandable, the request for a new size
        // will throw an exception.
        std::size_t bufferSize = getSize() + size;
        setSize(bufferSize);
    }
 
    std::memcpy(m_buffer.data() + m_pos, data, size);
    m_pos += size;
}
 
}