RecordComponent.hpp

/* Copyright 2017-2021 Fabian Koller, Axel Huebl and Franz Poeschel
 *
 * 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/Dataset.hpp"
#include "openPMD/Datatype.hpp"
#include "openPMD/auxiliary/ShareRaw.hpp"
#include "openPMD/auxiliary/TypeTraits.hpp"
#include "openPMD/auxiliary/UniquePtr.hpp"
#include "openPMD/backend/Attributable.hpp"
#include "openPMD/backend/BaseRecordComponent.hpp"
 
// comment to prevent this include from being moved by clang-format
#include "openPMD/DatatypeMacros.hpp"
 
#include <array>
#include <cmath>
#include <limits>
#include <memory>
#include <queue>
#include <sstream>
#include <stdexcept>
#include <string>
#include <type_traits>
#include <utility>
#include <variant>
#include <vector>
 
// expose private and protected members for invasive testing
#ifndef OPENPMD_protected
#define OPENPMD_protected protected:
#endif
 
namespace openPMD
{
 
template <typename T>
class DynamicMemoryView;
 
class RecordComponent;
 
namespace internal
{
    class RecordComponentData : public BaseRecordComponentData
    {
    public:
        RecordComponentData();
 
        RecordComponentData(RecordComponentData const &) = delete;
        RecordComponentData(RecordComponentData &&) = delete;
 
        RecordComponentData &operator=(RecordComponentData const &) = delete;
        RecordComponentData &operator=(RecordComponentData &&) = delete;

        std::queue<IOTask> m_chunks;
 
        void push_chunk(IOTask &&task);
        Attribute m_constantValue{-1};
        bool m_isEmpty = false;
        bool m_hasBeenExtended = false;
 
        void reset() override
        {
            BaseRecordComponentData::reset();
            m_chunks = std::queue<IOTask>();
            m_constantValue = -1;
            m_isEmpty = false;
            m_hasBeenExtended = false;
        }
    };
    template <typename, typename>
    class BaseRecordData;
} // namespace internal
 
template <typename>
class BaseRecord;
 
class RecordComponent : public BaseRecordComponent
{
    template <typename T, typename T_key, typename T_container>
    friend class Container;
    friend class Iteration;
    friend class ParticleSpecies;
    template <typename>
    friend class BaseRecord;
    template <typename, typename>
    friend class internal::BaseRecordData;
    friend class Record;
    friend class Mesh;
    template <typename>
    friend class DynamicMemoryView;
    friend class internal::RecordComponentData;
    friend class MeshRecordComponent;
    template <typename T>
    friend T &internal::makeOwning(T &self, Series);
 
public:
    enum class Allocation
    {
        USER,
        API,
        AUTO
    }; // Allocation

    RecordComponent(BaseRecord<RecordComponent> const &);
 
    RecordComponent &setUnitSI(double);

    RecordComponent &resetDataset(Dataset);
 
    uint8_t getDimensionality() const;
    Extent getExtent() const;

    template <typename T>
    RecordComponent &makeConstant(T);

    template <typename T>
    RecordComponent &makeEmpty(uint8_t dimensions);

    RecordComponent &makeEmpty(Datatype dt, uint8_t dimensions);

    bool empty() const;

    template <typename T>
    std::shared_ptr<T> loadChunk(Offset = {0u}, Extent = {-1u});
 
#define OPENPMD_ENUMERATE_TYPES(type) , std::shared_ptr<type>
    using shared_ptr_dataset_types = auxiliary::detail::variant_tail_t<
        auxiliary::detail::bottom OPENPMD_FOREACH_DATASET_DATATYPE(
            OPENPMD_ENUMERATE_TYPES)>;
#undef OPENPMD_ENUMERATE_TYPES

    shared_ptr_dataset_types loadChunkVariant(Offset = {0u}, Extent = {-1u});

    template <typename T>
    void loadChunk(std::shared_ptr<T> data, Offset offset, Extent extent);

    template <typename T>
    void loadChunk(std::shared_ptr<T[]> data, Offset offset, Extent extent);

    template <typename T>
    void loadChunkRaw(T *data, Offset offset, Extent extent);

    template <typename T>
    void storeChunk(std::shared_ptr<T> data, Offset offset, Extent extent);

    template <typename T>
    void storeChunk(std::shared_ptr<T[]> data, Offset offset, Extent extent);

    template <typename T>
    void storeChunk(UniquePtrWithLambda<T> data, Offset offset, Extent extent);

    template <typename T, typename Del>
    void storeChunk(std::unique_ptr<T, Del> data, Offset offset, Extent extent);

    template <typename T>
    void storeChunkRaw(T const *data, Offset offset, Extent extent);

    template <typename T_ContiguousContainer>
    typename std::enable_if_t<
        auxiliary::IsContiguousContainer_v<T_ContiguousContainer>>
    storeChunk(
        T_ContiguousContainer &data,
        Offset offset = {0u},
        Extent extent = {-1u});

    template <typename T, typename F>
    DynamicMemoryView<T>
    storeChunk(Offset offset, Extent extent, F &&createBuffer);

    template <typename T>
    DynamicMemoryView<T> storeChunk(Offset, Extent);

    template <typename Visitor, typename... Args>
    auto visit(Args &&...args) -> decltype(Visitor::template call<char>(
        std::declval<RecordComponent &>(), std::forward<Args>(args)...));
 
    static constexpr char const *const SCALAR = "\vScalar";
 
protected:
    void flush(std::string const &, internal::FlushParams const &);
    void read(bool require_unit_si);
 
private:
    RecordComponent &makeEmpty(Dataset d);
 
    void storeChunk(
        auxiliary::WriteBuffer buffer, Datatype datatype, Offset o, Extent e);
 
    // clang-format off
OPENPMD_protected
    // clang-format on
 
    using Data_t = internal::RecordComponentData;
    std::shared_ptr<Data_t> m_recordComponentData;
 
    RecordComponent();
    RecordComponent(NoInit);
 
    inline Data_t const &get() const
    {
        // cannot call this in the const overload
        // datasetDefined(*m_recordComponentData);
        return *m_recordComponentData;
    }
 
    inline Data_t &get()
    {
        setDatasetDefined(*m_recordComponentData);
        return *m_recordComponentData;
    }
 
    inline std::shared_ptr<Data_t> getShared()
    {
        return m_recordComponentData;
    }
 
    inline void setData(std::shared_ptr<internal::RecordComponentData> data)
    {
        m_recordComponentData = std::move(data);
        BaseRecordComponent::setData(m_recordComponentData);
    }
 
    void readBase(bool require_unit_si);
 
    template <typename T>
    void verifyChunk(Offset const &, Extent const &) const;
 
    void verifyChunk(Datatype, Offset const &, Extent const &) const;
}; // RecordComponent
 
namespace internal
{
    // Must put this after the definition of RecordComponent due to the
    // deque<RecordComponent>
    struct HomogenizeExtents
    {
        std::deque<RecordComponent> without_extent;
        std::optional<Extent> retrieved_extent;
        bool verify_homogeneous_extents = true;
 
        explicit HomogenizeExtents();
        HomogenizeExtents(bool verify_homogeneous_extents);
 
        void check_extent(Attributable const &callsite, RecordComponent &);
        auto merge(Attributable const &callsite, HomogenizeExtents)
            -> HomogenizeExtents &;
        void homogenize(Attributable const &callsite) &&;
    };
} // namespace internal
 
} // namespace openPMD
 
#include "openPMD/UndefDatatypeMacros.hpp"
// comment to prevent these includes from being moved by clang-format
#include "RecordComponent.tpp"