BaseRecordComponent.hpp

/* Copyright 2017-2025 Fabian Koller, Axel Huebl, 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/ChunkInfo.hpp"
#include "openPMD/Dataset.hpp"
#include "openPMD/Error.hpp"
#include "openPMD/backend/Attributable.hpp"
 
#include <optional>
 
// expose private and protected members for invasive testing
#ifndef OPENPMD_protected
#define OPENPMD_protected protected:
#endif
 
namespace openPMD
{
namespace internal
{
    class BaseRecordComponentData : virtual public AttributableData
    {
    public:
        std::optional<Dataset> m_dataset;
        bool m_isConstant = false;
        bool m_datasetDefined = false;
 
        BaseRecordComponentData(BaseRecordComponentData const &) = delete;
        BaseRecordComponentData(BaseRecordComponentData &&) = delete;
        BaseRecordComponentData &
        operator=(BaseRecordComponentData const &) = delete;
        BaseRecordComponentData &operator=(BaseRecordComponentData &&) = delete;
 
        BaseRecordComponentData() = default;
 
        virtual void reset()
        {
            m_dataset = std::nullopt;
            m_isConstant = false;
            m_datasetDefined = false;
        }
    };
} // namespace internal
 
template <typename>
class BaseRecord;
 
class BaseRecordComponent : virtual public Attributable
{
    template <typename T, typename T_key, typename T_container>
    friend class Container;
 
public:
    /*
     * Need to define these manually due to the virtual inheritance from
     * Attributable.
     * Otherwise, they would only run from the most derived class
     * if explicitly called.
     * If not defining these, a user could destroy copy/move constructors/
     * assignment operators by deriving from any class that has a virtual
     * Attributable somewhere.
     * Care must be taken in move constructors/assignment operators to not move
     * multiple times (which could happen in diamond inheritance situations).
     */
 
    BaseRecordComponent(BaseRecordComponent const &other)
        : Attributable(NoInit())
    {
        m_attri = other.m_attri;
        m_baseRecordComponentData = other.m_baseRecordComponentData;
    }
 
    BaseRecordComponent(BaseRecordComponent &&other) : Attributable(NoInit())
    {
        if (other.m_attri)
        {
            m_attri = std::move(other.m_attri);
        }
        m_baseRecordComponentData = std::move(other.m_baseRecordComponentData);
    }
 
    BaseRecordComponent &operator=(BaseRecordComponent const &other)
    {
        m_attri = other.m_attri;
        m_baseRecordComponentData = other.m_baseRecordComponentData;
        return *this;
    }
 
    BaseRecordComponent &operator=(BaseRecordComponent &&other)
    {
        if (other.m_attri)
        {
            m_attri = std::move(other.m_attri);
        }
        m_baseRecordComponentData = std::move(other.m_baseRecordComponentData);
        return *this;
    }
 
    double unitSI() const;
 
    BaseRecordComponent &resetDatatype(Datatype);
 
    Datatype getDatatype() const;

    bool constant() const;
 
    std::optional<size_t> joinedDimension() const;

    ChunkTable availableChunks();
 
protected:
    using Data_t = internal::BaseRecordComponentData;
    std::shared_ptr<Data_t> m_baseRecordComponentData;
 
    inline Data_t const &get() const
    {
        return *m_baseRecordComponentData;
    }
 
    inline Data_t &get()
    {
        return *m_baseRecordComponentData;
    }
 
    inline void setData(std::shared_ptr<Data_t> data)
    {
        m_baseRecordComponentData = std::move(data);
        Attributable::setData(m_baseRecordComponentData);
    }
 
    virtual void setDatasetDefined(Data_t &);
 
    bool datasetDefined() const;
 
    BaseRecordComponent();
    BaseRecordComponent(NoInit);
}; // BaseRecordComponent
 
namespace detail
{
    template <typename T_RecordComponent>
    struct DefaultValue
    {
        template <typename T>
        static void call(T_RecordComponent &rc)
        {
            rc.makeConstant(T());
        }
 
        template <unsigned n, typename... Args>
        static void call(Args &&...)
        {
            throw std::runtime_error(
                "makeEmpty: Datatype not supported by openPMD.");
        }
    };
} // namespace detail
} // namespace openPMD