binary_archive.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 "bitpit_common.hpp"
 
#include "binary_archive.hpp"
 
namespace bitpit {
 
const std::string BinaryArchive::EXTENSION_DEFAULT = "dat";
 
std::string BinaryArchive::generatePath(const std::string &name, int block)
{
    return generatePath(name, EXTENSION_DEFAULT, block);
}
 
std::string BinaryArchive::generatePath(const std::string &name, const std::string &extension, int block)
{
    FileHandler fileHandler("", name, extension);
    if (block >= 0) {
        fileHandler.setParallel(true);
        fileHandler.setBlock(block);
    }
 
    return fileHandler.getPath();
}
 
BinaryArchive::BinaryArchive()
    : m_version(VERSION_UNDEFINED)
{
}
 
BinaryArchive::~BinaryArchive()
{
    close();
}
 
void BinaryArchive::open(const std::string &name, const std::string &extension,
                         ios_base::openmode mode, int block)
{
    if (is_open()) {
        close();
    }
 
    m_path = generatePath(name, extension, block);
    std::fstream::open(m_path.c_str(), std::ios::binary | mode);
    if (!good()) {
        throw std::runtime_error("Unable to open the binary archive \"" + getPath() + "\".");
    }
}
 
int BinaryArchive::getVersion() const
{
    return m_version;
}
 
std::string BinaryArchive::getHeader() const
{
    return m_header;
}
 
std::string BinaryArchive::getPath() const
{
    return m_path;
}
 
IBinaryArchive::IBinaryArchive(const std::string &name, int block)
{
    open(name, EXTENSION_DEFAULT, block);
}
 
IBinaryArchive::IBinaryArchive(const std::string &name, const std::string &extension, int block)
{
    open(name, extension, block);
}
 
void IBinaryArchive::open(const std::string &name, int block)
{
    open(name, EXTENSION_DEFAULT, block);
}
 
void IBinaryArchive::open(const std::string &name, const std::string &extension, int block)
{
    // Reset the header
    m_header.clear();
 
    // Open the stream
    BinaryArchive::open(name, extension, std::ios::in | std::ios_base::binary, block);
 
    // Read the header
    std::vector<char> rawHeader(HEADER_SIZE);
    utils::binary::read(*this, rawHeader.data(), rawHeader.size());
    m_header = std::string(rawHeader.begin(), rawHeader.end());
 
    // Read the version
    utils::binary::read(*this, m_version);
}
 
std::istream & IBinaryArchive::getStream()
{
    return *this;
}
 
bool IBinaryArchive::checkVersion(int version)
{
    return (version == m_version);
}
 
OBinaryArchive::OBinaryArchive(const std::string &name, int version, int block)
{
    open(name, EXTENSION_DEFAULT, version, "", block);
}
 
OBinaryArchive::OBinaryArchive(const std::string &name, int version,
                               const std::string &header, int block)
{
    open(name, EXTENSION_DEFAULT, version, header, block);
}
 
OBinaryArchive::OBinaryArchive(const std::string &name, const std::string &extension,
                               int version, int block)
{
    open(name, extension, version, "", block);
}
 
 
OBinaryArchive::OBinaryArchive(const std::string &name, const std::string &extension,
                               int version, const std::string &header, int block)
{
    open(name, extension, version, header, block);
}
 
void OBinaryArchive::open(const std::string &name, int version, int block)
{
    open(name, EXTENSION_DEFAULT, version, "", block);
}
 
void OBinaryArchive::open(const std::string &name, int version,
                          const std::string &header, int block)
{
    open(name, EXTENSION_DEFAULT, version, header, block);
}
 
void OBinaryArchive::open(const std::string &name, const std::string &extension,
                          int version, int block)
{
    open(name, extension, version, "", block);
}
 
void OBinaryArchive::open(const std::string &name, const std::string &extension,
                          int version, const std::string &header, int block)
{
    // Open the stream
    BinaryArchive::open(name, extension, std::ios::out | std::ios_base::binary, block);
 
    // Write the header
    //
    // The header should be written using the write overload that takes in
    // input characters, because the one that takes in input strings would
    // write into the archive also the string length.
    std::string archiveHeader(header);
    archiveHeader.resize(HEADER_SIZE, ' ');
    utils::binary::write(*this, archiveHeader.data(), archiveHeader.size());
 
    // Write the version
    utils::binary::write(*this, version);
}
 
std::ostream & OBinaryArchive::getStream()
{
    return *this;
}
 
}