Merge commit 'dbf41f8' into HEAD

Author: trile965

NAMESPACE

@@ -49,7 +49,6 @@ export(Read10XH5Content)
 export(ReadColSumSpMt)
 export(ReadDoubleVector)
 export(ReadIntegerVector)
-export(ReadRootDataset)
 export(ReadRowSumSpMt)
 export(ReadSpMt)
 export(ReadSpMtAsS4)

R/RcppExports.R

@@ -165,17 +165,6 @@ WriteRootDataset <- function(filePath, datasetName, datasetVal) {
     invisible(.Call(`_Signac_WriteRootDataset`, filePath, datasetName, datasetVal))
 }
 
-#' ReadRootDataset
-#'
-#' Read a string vector from root group
-#'
-#' @param filePath A fiel path
-#' @param datasetName A dataset name
-#' @export
-ReadRootDataset <- function(filePath, datasetName) {
-    .Call(`_Signac_ReadRootDataset`, filePath, datasetName)
-}
-
 #' ReadIntegerVector
 #'
 #' This function is used to read a integer vector from hdf5 file

inst/highfive/H5Attribute.hpp

@@ -11,17 +11,27 @@
 
 #include <vector>
 
+#include "H5DataSpace.hpp"
+#include "H5DataType.hpp"
 #include "H5Object.hpp"
+#include "bits/H5Path_traits.hpp"
 
 namespace HighFive {
 
-template <typename Derivate>
-class AnnotateTraits;
-class DataType;
-class DataSpace;
-
-class Attribute : public Object {
+///
+/// \brief Class representing an attribute of a dataset or group
+///
+class Attribute : public Object,
+                  public PathTraits<Attribute> {
   public:
+
+    const static ObjectType type = ObjectType::Attribute;
+
+    ///
+    /// \brief return the name of the current attribute
+    /// \return the name of the attribute
+    std::string getName() const;
+
     size_t getStorageSize() const;
 
     ///
@@ -53,6 +63,12 @@ class Attribute : public Object {
     template <typename T>
     void read(T& array) const;
 
+    ///
+    /// Read the attribute into a buffer
+    ///
+    template <typename T>
+    void read(T* array, const DataType& dtype = DataType()) const;
+
     ///
     /// Write the integrality N-dimension buffer to this attribute
     /// An exception is raised if the numbers of dimension of the buffer and of
@@ -63,13 +79,22 @@ class Attribute : public Object {
     template <typename T>
     void write(const T& buffer);
 
+    ///
+    /// Write a buffer to this attribute
+    ///
+    template <typename T>
+    void write_raw(const T* buffer, const DataType& dtype = DataType());
+
+    // No empty attributes
+    Attribute() = delete;
+
   private:
-    Attribute();
-    template <typename Derivate>
-    friend class ::HighFive::AnnotateTraits;
+    using Object::Object;
+
+    template <typename Derivate> friend class ::HighFive::AnnotateTraits;
 };
-}
 
-#include "bits/H5Attribute_misc.hpp"
+}  // namespace HighFive
+
 
 #endif // H5ATTRIBUTE_HPP

inst/highfive/H5DataSet.hpp

@@ -11,24 +11,39 @@
 
 #include <vector>
 
+#include "H5DataSpace.hpp"
+#include "H5DataType.hpp"
 #include "H5Object.hpp"
+#include "bits/H5_definitions.hpp"
 #include "bits/H5Annotate_traits.hpp"
 #include "bits/H5Slice_traits.hpp"
+#include "bits/H5Path_traits.hpp"
+#include "bits/H5_definitions.hpp"
 
 namespace HighFive {
 
-template <typename Derivate>
-class NodeTraits;
-template <typename Derivate>
-class SliceTraits;
-class DataType;
-class DataSpace;
-
+///
+/// \brief Class representing a dataset.
+///
 class DataSet : public Object,
                 public SliceTraits<DataSet>,
-                public AnnotateTraits<DataSet> {
+                public AnnotateTraits<DataSet>,
+                public PathTraits<DataSet> {
   public:
-    size_t getStorageSize() const;
+
+    const static ObjectType type = ObjectType::Dataset;
+
+    ///
+    /// \brief getStorageSize
+    /// \return returns the amount of storage allocated for a dataset.
+    ///
+    uint64_t getStorageSize() const;
+
+    ///
+    /// \brief getOffset
+    /// \return returns DataSet address in file
+    ///
+    uint64_t getOffset() const;
 
     ///
     /// \brief getDataType
@@ -49,27 +64,45 @@ class DataSet : public Object,
     ///
     DataSpace getMemSpace() const;
 
-    ///
-    /// \brief getOffset
-    /// \return returns DataSet address in file
-    /// class
-    ///
-    size_t getOffset() const;
-    
+
     /// \brief Change the size of the dataset
     ///
     /// This requires that the dataset was created with chunking, and you would
     /// generally want to have set a larger maxdims setting
     /// \param dims New size of the dataset
     void resize(const std::vector<size_t>& dims);
 
-  private:
-    DataSet();
-    template <typename Derivate>
-    friend class ::HighFive::NodeTraits;
+
+    /// \brief Get the dimensions of the whole DataSet.
+    ///       This is a shorthand for getSpace().getDimensions()
+    /// \return The shape of the current HighFive::DataSet
+    ///
+    inline std::vector<size_t> getDimensions() const {
+        return getSpace().getDimensions();
+    }
+
+    /// \brief Get the total number of elements in the current dataset.
+    ///       E.g. 2x2x2 matrix has size 8.
+    ///       This is a shorthand for getSpace().getTotalCount()
+    /// \return The shape of the current HighFive::DataSet
+    ///
+    inline size_t getElementCount() const {
+        return getSpace().getElementCount();
+    }
+
+    H5_DEPRECATED("Default constructor creates unsafe uninitialized objects")
+    DataSet() = default;
+
+  protected:
+    using Object::Object;  // bring DataSet(hid_t)
+
+    DataSet(Object&& o) noexcept : Object(std::move(o)) {}
+
+    friend class Reference;
+    template <typename Derivate> friend class NodeTraits;
+
 };
-}
 
-#include "bits/H5DataSet_misc.hpp"
+}  // namespace HighFive
 
 #endif // H5DATASET_HPP

inst/highfive/H5DataSpace.hpp

@@ -16,30 +16,35 @@
 #include <initializer_list>
 
 #ifdef H5_USE_BOOST
-
-// In some versions of Boost (starting with 1.64), you have to include the serialization header before ublas
+// starting Boost 1.64, serialization header must come before ublas
 #include <boost/serialization/vector.hpp>
-
 #include <boost/multi_array.hpp>
 #include <boost/numeric/ublas/matrix.hpp>
 #endif
 
+#ifdef H5_USE_EIGEN
+#include <Eigen/Eigen>
+#endif
+
 #include "H5Object.hpp"
+#include "bits/H5_definitions.hpp"
 
 namespace HighFive {
 
-class File;
-class DataSet;
-
+///
+/// \brief Class representing the space (dimensions) of a dataset
+///
 class DataSpace : public Object {
   public:
 
+    const static ObjectType type = ObjectType::DataSpace;
+
     static const size_t UNLIMITED = SIZE_MAX;
 
     /// dataspace type
     enum DataspaceType {
-        datascape_scalar,
-        datascape_null
+        dataspace_scalar,
+        dataspace_null
         // simple dataspace are handle directly from their dimensions
     };
 
@@ -50,10 +55,14 @@ class DataSpace : public Object {
     ///  etc...
     explicit DataSpace(const std::vector<size_t>& dims);
 
+    // create a dataspace of N-dimensions
+    template <size_t N>
+    explicit DataSpace(const std::array<size_t, N>& dims);
+
     /// Make sure that DataSpace({1,2,3}) works on GCC. This is
-    /// the shortcut form of the vector initalizer, but one some compilers (gcc)
+    /// the shortcut form of the vector initializer, but one some compilers (gcc)
     /// this does not resolve correctly without this constructor.
-    explicit DataSpace(std::initializer_list<size_t> items);
+    DataSpace(const std::initializer_list<size_t>& items);
 
     /// Allow directly listing 1 or more dimensions to initialize,
     /// that is, DataSpace(1,2) means DataSpace(std::vector<size_t>{1,2}).
@@ -68,8 +77,8 @@ class DataSpace : public Object {
               const IT end);
 
     /// \brief Create a resizable N-dimensional dataspace
-    /// \params dims Initial size of dataspace
-    /// \params maxdims Maximum size of the dataspace
+    /// \param dims Initial size of dataspace
+    /// \param maxdims Maximum size of the dataspace
     explicit DataSpace(const std::vector<size_t>& dims,
                        const std::vector<size_t>& maxdims);
 
@@ -93,48 +102,33 @@ class DataSpace : public Object {
     /// associated dataset dimension
     std::vector<size_t> getDimensions() const;
 
+    /// \brief getElementCount
+    /// \return the total number of elements in the dataspace
+    size_t getElementCount() const;
+
     /// \brief getMaxDimensions
     /// \return return a vector of N-element, each element is the size of the
     /// associated dataset maximum dimension
     std::vector<size_t> getMaxDimensions() const;
 
-    /// Create a dataspace matching a single element of a basic type
-    ///  supported type are integrals (int,long), floating points (float,double)
-    ///  and std::string
-    template <typename ScalarValue>
-    static DataSpace From(const ScalarValue& scalar_value);
+    /// Create a dataspace matching a type accepted by details::inspector
+    template <typename T>
+    static DataSpace From(const T& value);
 
-    /// Create a dataspace matching the container dimensions and size
-    /// Supported Containers are:
-    ///  - vector of fundamental types
-    ///  - vector of std::string
-    ///  - boost::multi_array (with H5_USE_BOOST defined)
-    template <typename Value>
-    static DataSpace From(const std::vector<Value>& vec);
-
-    /// Create a dataspace matching the container dimensions for a
-    /// std::array.
-    template <typename Value, std::size_t N>
-    static DataSpace From(const std::array<Value, N>&);
-
-
-#ifdef H5_USE_BOOST
-    template <typename Value, std::size_t Dims>
-    static DataSpace From(const boost::multi_array<Value, Dims>& container);
-
-    template <typename Value>
-    static DataSpace From(const boost::numeric::ublas::matrix<Value>& mat);
-#endif
+    template <std::size_t N, std::size_t Width>
+    static DataSpace FromCharArrayStrings(const char(&)[N][Width]);
 
   protected:
-    explicit DataSpace();
+    DataSpace() = default;
 
     friend class Attribute;
     friend class File;
     friend class DataSet;
 };
-}
 
+}  // namespace HighFive
+
+// We include bits right away since DataSpace is user-constructible
 #include "bits/H5Dataspace_misc.hpp"
 
 #endif // H5DATASPACE_HPP