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/backend/BaseRecordComponent.hpp"
#include "openPMD/auxiliary/ShareRaw.hpp"
#include "openPMD/Dataset.hpp"
 
#include <cmath>
#include <memory>
#include <limits>
#include <queue>
#include <string>
#include <sstream>
#include <stdexcept>
#include <type_traits>
#include <vector>
#include <array>
 
// expose private and protected members for invasive testing
#ifndef OPENPMD_protected
#   define OPENPMD_protected protected
#endif
 
 
namespace openPMD
{
namespace traits
{
template< typename T >
struct IsContiguousContainer
{
    static constexpr bool value = false;
};
 
template< typename T_Value >
struct IsContiguousContainer< std::vector< T_Value > >
{
    static constexpr bool value = true;
};
 
template<
    typename T_Value,
    std::size_t N
>
struct IsContiguousContainer< std::array< T_Value, N > >
{
    static constexpr bool value = true;
};
} // namespace traits
 
template< typename T >
class DynamicMemoryView;
 
class RecordComponent : public BaseRecordComponent
{
    template<
            typename T,
            typename T_key,
            typename T_container
    >
    friend class Container;
    friend class Iteration;
    friend class ParticleSpecies;
    template< typename T_elem >
    friend class BaseRecord;
    friend class Record;
    friend class Mesh;
    template< typename >
    friend class DynamicMemoryView;
 
public:
    enum class Allocation
    {
        USER,
        API,
        AUTO
    }; // Allocation
 
    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 } );
 
    template< typename T >
    void loadChunk(
        std::shared_ptr< T >,
        Offset,
        Extent );
 
    template< typename T >
    void storeChunk(std::shared_ptr< T >, Offset, Extent);
 
    template< typename T_ContiguousContainer >
    typename std::enable_if<
        traits::IsContiguousContainer< T_ContiguousContainer >::value
    >::type
    storeChunk(T_ContiguousContainer &, Offset = {0u}, Extent = {-1u});
 
    template< typename T, typename F >
    DynamicMemoryView< T > storeChunk( Offset, Extent, F && createBuffer );
 
    template< typename T >
    DynamicMemoryView< T > storeChunk( Offset, Extent );
 
    static constexpr char const * const SCALAR = "\vScalar";
 
    virtual ~RecordComponent() = default;
 
OPENPMD_protected:
    RecordComponent();
 
    void readBase();
 
    std::shared_ptr< std::queue< IOTask > > m_chunks;
    std::shared_ptr< Attribute > m_constantValue;
    std::shared_ptr< bool > m_isEmpty = std::make_shared< bool >( false );
    // User has extended the dataset, but the EXTEND task must yet be flushed
    // to the backend
    std::shared_ptr< bool > m_hasBeenExtended =
        std::make_shared< bool >( false );
 
private:
    void flush(std::string const&);
    virtual void read();
 
    RecordComponent& makeEmpty( Dataset d );
 
    bool dirtyRecursive() const;
 
protected:
 
    std::shared_ptr< std::string > m_name = std::make_shared< std::string >();
 
}; // RecordComponent
} // namespace openPMD
 
#include "RecordComponent.tpp"