AbstractIOHandlerImpl.hpp

/* Copyright 2018-2021 Fabian Koller
 *
 * 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/IO/AbstractIOHandler.hpp"
#include "openPMD/IO/IOTask.hpp"
#include "openPMD/auxiliary/DerefDynamicCast.hpp"
 
#include <future>
 
 
namespace openPMD
{
// class AbstractIOHandler;
class Writable;
 
class AbstractIOHandlerImpl
{
public:
    AbstractIOHandlerImpl(AbstractIOHandler *handler)
    : m_handler{handler}
    { }
 
    virtual ~AbstractIOHandlerImpl() = default;
 
    virtual std::future< void > flush()
    {
        using namespace auxiliary;
 
        while( !(*m_handler).m_work.empty() )
        {
            IOTask& i = (*m_handler).m_work.front();
            try
            {
                switch( i.operation )
                {
                    using O = Operation;
                    case O::CREATE_FILE:
                        createFile(i.writable, deref_dynamic_cast< Parameter< Operation::CREATE_FILE > >(i.parameter.get()));
                        break;
                    case O::CREATE_PATH:
                        createPath(i.writable, deref_dynamic_cast< Parameter< O::CREATE_PATH > >(i.parameter.get()));
                        break;
                    case O::CREATE_DATASET:
                        createDataset(i.writable, deref_dynamic_cast< Parameter< O::CREATE_DATASET > >(i.parameter.get()));
                        break;
                    case O::EXTEND_DATASET:
                        extendDataset(i.writable, deref_dynamic_cast< Parameter< O::EXTEND_DATASET > >(i.parameter.get()));
                        break;
                    case O::OPEN_FILE:
                        openFile(i.writable, deref_dynamic_cast< Parameter< O::OPEN_FILE > >(i.parameter.get()));
                        break;
                    case O::CLOSE_FILE:
                        closeFile(i.writable, deref_dynamic_cast< Parameter< O::CLOSE_FILE > >(i.parameter.get()));
                        break;
                    case O::OPEN_PATH:
                        openPath(i.writable, deref_dynamic_cast< Parameter< O::OPEN_PATH > >(i.parameter.get()));
                        break;
                    case O::CLOSE_PATH:
                        closePath(i.writable, deref_dynamic_cast< Parameter< O::CLOSE_PATH > >(i.parameter.get()));
                        break;
                    case O::OPEN_DATASET:
                        openDataset(i.writable, deref_dynamic_cast< Parameter< O::OPEN_DATASET > >(i.parameter.get()));
                        break;
                    case O::DELETE_FILE:
                        deleteFile(i.writable, deref_dynamic_cast< Parameter< O::DELETE_FILE > >(i.parameter.get()));
                        break;
                    case O::DELETE_PATH:
                        deletePath(i.writable, deref_dynamic_cast< Parameter< O::DELETE_PATH > >(i.parameter.get()));
                        break;
                    case O::DELETE_DATASET:
                        deleteDataset(i.writable, deref_dynamic_cast< Parameter< O::DELETE_DATASET > >(i.parameter.get()));
                        break;
                    case O::DELETE_ATT:
                        deleteAttribute(i.writable, deref_dynamic_cast< Parameter< O::DELETE_ATT > >(i.parameter.get()));
                        break;
                    case O::WRITE_DATASET:
                        writeDataset(i.writable, deref_dynamic_cast< Parameter< O::WRITE_DATASET > >(i.parameter.get()));
                        break;
                    case O::WRITE_ATT:
                        writeAttribute(i.writable, deref_dynamic_cast< Parameter< O::WRITE_ATT > >(i.parameter.get()));
                        break;
                    case O::READ_DATASET:
                        readDataset(i.writable, deref_dynamic_cast< Parameter< O::READ_DATASET > >(i.parameter.get()));
                        break;
                    case O::GET_BUFFER_VIEW:
                        getBufferView(i.writable, deref_dynamic_cast< Parameter< O::GET_BUFFER_VIEW > >(i.parameter.get()));
                        break;
                    case O::READ_ATT:
                        readAttribute(i.writable, deref_dynamic_cast< Parameter< O::READ_ATT > >(i.parameter.get()));
                        break;
                    case O::LIST_PATHS:
                        listPaths(i.writable, deref_dynamic_cast< Parameter< O::LIST_PATHS > >(i.parameter.get()));
                        break;
                    case O::LIST_DATASETS:
                        listDatasets(i.writable, deref_dynamic_cast< Parameter< O::LIST_DATASETS > >(i.parameter.get()));
                        break;
                    case O::LIST_ATTS:
                        listAttributes(i.writable, deref_dynamic_cast< Parameter< O::LIST_ATTS > >(i.parameter.get()));
                        break;
                    case O::ADVANCE:
                        advance(i.writable, deref_dynamic_cast< Parameter< O::ADVANCE > >(i.parameter.get()));
                        break;
                    case O::AVAILABLE_CHUNKS:
                        availableChunks(i.writable, deref_dynamic_cast< Parameter< O::AVAILABLE_CHUNKS > >(i.parameter.get()));
                        break;
                }
            } catch (unsupported_data_error&)
            {
                (*m_handler).m_work.pop();
                throw;
            }
            (*m_handler).m_work.pop();
        }
        return std::future< void >();
    }
 
  virtual void
  closeFile( Writable *, Parameter< Operation::CLOSE_FILE > const & ) = 0;
 
  virtual void
  advance( Writable *, Parameter< Operation::ADVANCE > & )
  {}
 
  virtual void
  closePath( Writable *, Parameter< Operation::CLOSE_PATH > const & )
  {}
 
  virtual void
  availableChunks( Writable *, Parameter< Operation::AVAILABLE_CHUNKS > & ) = 0;
 
  virtual void createFile(Writable*, Parameter< Operation::CREATE_FILE > const&) = 0;
  virtual void createPath(Writable*, Parameter< Operation::CREATE_PATH > const&) = 0;
  virtual void createDataset(Writable*, Parameter< Operation::CREATE_DATASET > const&) = 0;
  virtual void extendDataset(Writable*, Parameter< Operation::EXTEND_DATASET > const&) = 0;
  virtual void openFile(Writable*, Parameter< Operation::OPEN_FILE > const&) = 0;
  virtual void openPath(Writable*, Parameter< Operation::OPEN_PATH > const&) = 0;
  virtual void openDataset(Writable*, Parameter< Operation::OPEN_DATASET > &) = 0;
  virtual void deleteFile(Writable*, Parameter< Operation::DELETE_FILE > const&) = 0;
  virtual void deletePath(Writable*, Parameter< Operation::DELETE_PATH > const&) = 0;
  virtual void deleteDataset(Writable*, Parameter< Operation::DELETE_DATASET > const&) = 0;
  virtual void deleteAttribute(Writable*, Parameter< Operation::DELETE_ATT > const&) = 0;
  virtual void writeDataset(Writable*, Parameter< Operation::WRITE_DATASET > const&) = 0;
 
  virtual void getBufferView(Writable*, Parameter< Operation::GET_BUFFER_VIEW >& parameters)
  {
        // default implementation: operation unsupported by backend
        parameters.out->backendManagedBuffer = false;
  }
  virtual void writeAttribute(Writable*, Parameter< Operation::WRITE_ATT > const&) = 0;
  virtual void readDataset(Writable*, Parameter< Operation::READ_DATASET > &) = 0;
  virtual void readAttribute(Writable*, Parameter< Operation::READ_ATT > &) = 0;
  virtual void listPaths(Writable*, Parameter< Operation::LIST_PATHS > &) = 0;
  virtual void listDatasets(Writable*, Parameter< Operation::LIST_DATASETS > &) = 0;
  virtual void listAttributes(Writable*, Parameter< Operation::LIST_ATTS > &) = 0;
 
  AbstractIOHandler* m_handler;
};  //AbstractIOHandlerImpl
} // openPMD