Series.hpp

/* Copyright 2017-2020 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/backend/Attributable.hpp"
#include "openPMD/backend/Container.hpp"
#include "openPMD/IO/AbstractIOHandler.hpp"
#include "openPMD/IO/Access.hpp"
#include "openPMD/IO/Format.hpp"
#include "openPMD/Iteration.hpp"
#include "openPMD/IterationEncoding.hpp"
#include "openPMD/Streaming.hpp"
#include "openPMD/auxiliary/Option.hpp"
#include "openPMD/auxiliary/Variant.hpp"
#include "openPMD/backend/Attributable.hpp"
#include "openPMD/backend/Container.hpp"
#include "openPMD/config.hpp"
#include "openPMD/version.hpp"

#if openPMD_HAVE_MPI
#   include <mpi.h>
#endif

#include <map>
#include <string>

// expose private and protected members for invasive testing
#ifndef OPENPMD_private
#   define OPENPMD_private private
#endif


namespace openPMD
{
class ReadIterations;
class WriteIterations;

class Series : public Attributable
{
    friend class Iteration;
    friend class SeriesIterator;

public:
#if openPMD_HAVE_MPI
    Series(
        std::string const & filepath,
        Access at,
        MPI_Comm comm,
        std::string const & options = "{}" );
#endif

    Series(
        std::string const & filepath,
        Access at,
        std::string const & options = "{}" );
    ~Series();

    std::string openPMD() const;
    Series& setOpenPMD(std::string const& openPMD);

    uint32_t openPMDextension() const;
    Series& setOpenPMDextension(uint32_t openPMDextension);

    std::string basePath() const;
    Series& setBasePath(std::string const& basePath);

    std::string meshesPath() const;
    Series& setMeshesPath(std::string const& meshesPath);

    std::string particlesPath() const;
    Series& setParticlesPath(std::string const& particlesPath);

    std::string author() const;
    Series& setAuthor(std::string const& author);

    std::string software() const;
    Series& setSoftware(std::string const& newName, std::string const& newVersion = std::string("unspecified"));

    std::string softwareVersion() const;
    [[deprecated("Set the version with the second argument of setSoftware()")]]
    Series& setSoftwareVersion(std::string const& softwareVersion);

    std::string date() const;
    Series& setDate(std::string const& date);

    std::string softwareDependencies() const;
    Series& setSoftwareDependencies(std::string const& newSoftwareDependencies);

    std::string machine() const;
    Series& setMachine(std::string const& newMachine);

    IterationEncoding iterationEncoding() const;
    Series& setIterationEncoding(IterationEncoding iterationEncoding);

    std::string iterationFormat() const;
    Series& setIterationFormat(std::string const& iterationFormat);

    std::string name() const;

    Series& setName(std::string const& name);

    std::string backend() const;

    void flush();

    ReadIterations
    readIterations();

    WriteIterations
    writeIterations();

    Container< Iteration, uint64_t > iterations;

OPENPMD_private:
    struct ParsedInput;
    using iterations_iterator = decltype( iterations )::iterator;

    std::unique_ptr< ParsedInput > parseInput(std::string);
    void init(std::shared_ptr< AbstractIOHandler >, std::unique_ptr< ParsedInput >);
    void initDefaults();
    std::future< void > flush_impl(
        iterations_iterator begin, iterations_iterator end );
    void flushFileBased( iterations_iterator begin, iterations_iterator end );
    void flushGroupBased( iterations_iterator begin, iterations_iterator end );
    void flushMeshesPath();
    void flushParticlesPath();
    void readFileBased( );
    void readGroupBased( bool init = true );
    void
    readBase();
    void read();
    std::string iterationFilename( uint64_t i );
    void openIteration( uint64_t index, Iteration iteration );

    iterations_iterator
    indexOf( Iteration const & );

    AdvanceStatus
    advance(
        AdvanceMode mode,
        Attributable & file,
        iterations_iterator it,
        Iteration & iteration );

    std::shared_ptr< StepStatus > m_stepStatus =
        std::make_shared< StepStatus >( StepStatus::NoStep );

    static constexpr char const * const BASEPATH = "/data/%T/";

    std::shared_ptr< IterationEncoding > m_iterationEncoding;
    std::shared_ptr< std::string > m_name;
    std::shared_ptr< Format > m_format;

    std::shared_ptr< std::string > m_filenamePrefix;
    std::shared_ptr< std::string > m_filenamePostfix;
    std::shared_ptr< int > m_filenamePadding;

    std::shared_ptr< auxiliary::Option< WriteIterations > > m_writeIterations =
        std::make_shared< auxiliary::Option< WriteIterations > >();
}; // Series

class IndexedIteration : public Iteration
{
    friend class SeriesIterator;

public:
    using iterations_t = decltype( Series::iterations );
    using index_t = iterations_t::key_type;
    index_t const iterationIndex;

private:
    template< typename Iteration_t >
    IndexedIteration( Iteration_t && it, index_t index )
        : Iteration( std::forward< Iteration_t >( it ) )
        , iterationIndex( index )
    {
    }
};

class SeriesIterator
{
    using iteration_index_t = IndexedIteration::index_t;

    using maybe_series_t = auxiliary::Option< Series * >;

    maybe_series_t m_series;
    iteration_index_t m_currentIteration = 0;

    SeriesIterator();

public:
    SeriesIterator( Series * );

    SeriesIterator &
    operator++();

    IndexedIteration
    operator*();

    bool
    operator==( SeriesIterator const & other ) const;

    bool
    operator!=( SeriesIterator const & other ) const;

    static SeriesIterator
    end();
};

class ReadIterations
{
    friend class Series;

private:
    using iterations_t = decltype( Series::iterations );
    using iterator_t = SeriesIterator;

    Series * m_series;

    ReadIterations( Series * );

public:
    iterator_t
    begin();

    iterator_t
    end();
};

class WriteIterations : private Container< Iteration, uint64_t >
{
    friend class Series;

private:
    using iterations_t = Container< Iteration, uint64_t >;
    struct SharedResources
    {
        iterations_t iterations;
        auxiliary::Option< uint64_t > currentlyOpen;

        SharedResources( iterations_t );
        ~SharedResources();
    };

    using key_type = typename iterations_t::key_type;
    using value_type = typename iterations_t::key_type;
    WriteIterations( iterations_t );
    explicit WriteIterations() = default;
    std::shared_ptr< SharedResources > shared;

public:
    mapped_type &
    operator[]( key_type const & key ) override;
    mapped_type &
    operator[]( key_type && key ) override;
};
} // namespace openPMD