AbstractIOHandler.hpp

/* Copyright 2017-2021 Fabian Koller, Axel Huebl
 *
 * This file is part of openPMD-api.
 *
 * openPMD-api is free software: you can redistribute it and/or modify
 * it under the terms of of either the GNU General Public License or
 * the GNU Lesser General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * openPMD-api 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 General Public License and the GNU Lesser General Public License
 * for more details.
 *
 * You should have received a copy of the GNU General Public License
 * and the GNU Lesser General Public License along with openPMD-api.
 * If not, see <http://www.gnu.org/licenses/>.
 */
#pragma once
 
#include "openPMD/config.hpp"
#include "openPMD/IO/Access.hpp"
#include "openPMD/IO/Format.hpp"
#include "openPMD/IO/IOTask.hpp"
 
#if openPMD_HAVE_MPI
#   include <mpi.h>
#endif
 
#include <future>
#include <memory>
#include <queue>
#include <stdexcept>
#include <string>
 
 
namespace openPMD
{
class no_such_file_error : public std::runtime_error
{
public:
    no_such_file_error(std::string const& what_arg)
            : std::runtime_error(what_arg)
    { }
    virtual ~no_such_file_error() { }
};
 
class unsupported_data_error : public std::runtime_error
{
public:
    unsupported_data_error(std::string const& what_arg)
            : std::runtime_error(what_arg)
    { }
    virtual ~unsupported_data_error() { }
};
 
enum class FlushLevel : unsigned char
{
    UserFlush,
    InternalFlush,
    SkeletonOnly
};
 
 
class AbstractIOHandler
{
public:
#if openPMD_HAVE_MPI
    AbstractIOHandler(std::string path, Access at, MPI_Comm)
        : directory{std::move(path)},
          m_backendAccess{at},
          m_frontendAccess{at}
    { }
#endif
    AbstractIOHandler(std::string path, Access at)
        : directory{std::move(path)},
          m_backendAccess{at},
          m_frontendAccess{at}
    { }
    virtual ~AbstractIOHandler() = default;
 
    virtual void enqueue(IOTask const& iotask)
    {
        m_work.push(iotask);
    }
 
    virtual std::future< void > flush() = 0;
 
    virtual std::string backendName() const = 0;
 
    std::string const directory;
    Access const m_backendAccess;
    Access const m_frontendAccess;
    std::queue< IOTask > m_work;
    FlushLevel m_flushLevel = FlushLevel::InternalFlush;
}; // AbstractIOHandler
 
} // namespace openPMD