H5DataSpace.hpp

Go to the documentation of this file.

/*
 *  Copyright (c), 2017, Adrien Devresse <adrien.devresse@epfl.ch>
 *
 *  Distributed under the Boost Software License, Version 1.0.
 *    (See accompanying file LICENSE_1_0.txt or copy at
 *          http://www.boost.org/LICENSE_1_0.txt)
 *
 */
#pragma once
 
#include <vector>
#include <array>
#include <cstdint>
#include <type_traits>
#include <initializer_list>
 
#include "H5Object.hpp"
#include "bits/H5_definitions.hpp"
 
namespace HighFive {
 
namespace detail {
DataSpace make_data_space(hid_t hid);
}  // namespace detail
 
class DataSpace: public Object {
  public:
    const static ObjectType type = ObjectType::DataSpace;
 
    static const size_t UNLIMITED = SIZE_MAX;
 
    enum class DataspaceType {
        dataspace_scalar,  
        dataspace_null,    
        // simple dataspace are handle directly from their dimensions
    };
 
    // For backward compatibility: `DataSpace::dataspace_scalar`.
    constexpr static DataspaceType dataspace_scalar = DataspaceType::dataspace_scalar;
    constexpr static DataspaceType dataspace_null = DataspaceType::dataspace_null;
 
    explicit DataSpace(const std::vector<size_t>& dims);
 
    template <size_t N>
    explicit DataSpace(const std::array<size_t, N>& dims);
 
    DataSpace(const std::initializer_list<size_t>& dims);
 
    template <typename... Args>
    explicit DataSpace(size_t dim1, Args... dims);
 
    // Attention: Explicitly disable DataSpace(int_like, int_like) from trying
    //            to use this constructor
    template <typename IT,
              typename = typename std::enable_if<!std::is_integral<IT>::value, IT>::type>
    DataSpace(const IT begin, const IT end);
 
    explicit DataSpace(const std::vector<size_t>& dims, const std::vector<size_t>& maxdims);
 
    explicit DataSpace(DataspaceType space_type);
 
    static DataSpace Scalar();
 
    static DataSpace Null();
 
    DataSpace clone() const;
 
    size_t getNumberDimensions() const;
 
    std::vector<size_t> getDimensions() const;
 
    size_t getElementCount() const;
 
    std::vector<size_t> getMaxDimensions() const;
 
    template <typename T>
    static DataSpace From(const T& value);
 
    template <std::size_t N, std::size_t Width>
    static DataSpace FromCharArrayStrings(const char (&string_array)[N][Width]);
 
  protected:
    DataSpace() = default;
 
    static DataSpace fromId(hid_t hid) {
        DataSpace space;
        space._hid = hid;
 
        return space;
    }
 
    friend class Attribute;
    friend class File;
    friend class DataSet;
 
    friend DataSpace detail::make_data_space(hid_t hid);
};
 
}  // namespace HighFive
 
// We include bits right away since DataSpace is user-constructible
#include "bits/H5Dataspace_misc.hpp"