attribute.hpp

Go to the documentation of this file.

//
// (c) Copyright 2017 DESY,ESS
//
// This file is part of h5cpp.
//
// This library is free software; you can redistribute it and/or modify it
// under the terms of the GNU Lesser General Public License as published
// by the Free Software Foundation; either version 2.1 of the License, or
// (at your option) any later version.
//
// This library is distributed in the hope that it will be useful, but
// WITHOUT ANY WARRANTY; without even the implied warranty ofMERCHANTABILITY
// or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
// License for more details.
//
// You should have received a copy of the GNU Lesser General Public License
// along with this library; if not, write to the
// Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor
// Boston, MA  02110-1301 USA
// ===========================================================================
//
// Authors:
//   Eugen Wintersberger <eugen.wintersberger@desy.de>
//   Jan Kotanski <jan.kotanski@desy.de>
// Created on: Sep 14, 2017
//
#pragma once
 
#include <h5cpp/datatype/datatype.hpp>
#include <h5cpp/dataspace/dataspace.hpp>
#include <h5cpp/datatype/factory.hpp>
#include <h5cpp/dataspace/type_trait.hpp>
#include <h5cpp/property/dataset_transfer.hpp>
#include <h5cpp/core/object_handle.hpp>
#include <h5cpp/core/windows.hpp>
#include <h5cpp/core/variable_length_string.hpp>
#include <h5cpp/core/fixed_length_string.hpp>
#include <h5cpp/core/types.hpp>
#include <h5cpp/node/link.hpp>
#include <h5cpp/error/error.hpp>
#include <initializer_list>
#include <h5cpp/core/utilities.hpp>
#include <h5cpp/contrib/stl/vector.hpp>
 
namespace hdf5 {
namespace attribute {
 
class DLL_EXPORT Attribute
{
  public:
    Attribute(ObjectHandle &&handle,const node::Link &parent_link);
 
    Attribute() = default;
 
    datatype::Datatype datatype() const;
 
    dataspace::Dataspace dataspace() const;
 
    std::string name() const;
 
    bool is_valid() const;
 
    void close();
 
 
    operator hid_t() const
    {
      return static_cast<hid_t>(handle_);
    }
 
    const node::Link &parent_link() const noexcept;
 
    template<typename T>
    void write(const T& data) const;
 
    void write(const char *data) const;
 
    template<typename T>
    void write(const std::initializer_list<T> &list) const
    {
      write(std::vector<T>{list});
    }
 
    template<typename T>
    void write(const T& data,const datatype::Datatype &mem_type) const;
    void write(const char *data,const datatype::Datatype &mem_type) const;
 
    template<typename T>
    void read(T &data) const;
 
    template<typename T>
    void read(T &data,const datatype::Datatype &mem_type) const;
 
    void read(std::string &data, bool trim = false) const;
 
    void read(std::string &data, const datatype::Datatype &mem_type, bool trim = false) const;
 
  private:
    node::Link   parent_link_;
    ObjectHandle handle_;
 
    template<typename T>
    void read(T &data,const datatype::Datatype &mem_type, const datatype::Datatype &file_type) const;
 
  void read(std::string &data, const datatype::Datatype &mem_type, const datatype::Datatype &file_type, bool trim = false) const;
 
    template<typename T>
    void write_fixed_length_string(const T &data,
                                   const datatype::Datatype &mem_type) const
    {
      using Trait = FixedLengthStringTrait<T>;
      using SpaceTrait = hdf5::dataspace::TypeTrait<T>;
      auto buffer = Trait::to_buffer(data,mem_type,SpaceTrait::create(data));
 
      if(H5Awrite(static_cast<hid_t>(handle_),
                  static_cast<hid_t>(mem_type),
                  buffer.data())<0)
      {
        error::Singleton::instance().throw_with_stack("Failure to write data to attribute!");
      }
 
    }
 
    template<typename T>
    void write_variable_length_string(const T &data,
                                      const datatype::Datatype &mem_type) const
    {
      using Trait = VarLengthStringTrait<T>;
      auto buffer = Trait::to_buffer(data);
 
      if(H5Awrite(static_cast<hid_t>(handle_),
                  static_cast<hid_t>(mem_type),
                  buffer.data())<0)
      {
        error::Singleton::instance().throw_with_stack("Failure to write data to attribute!");
      }
 
    }
 
    template<typename T>
    void write_contiguous_data(const T &data,
                               const datatype::Datatype &mem_type) const
    {
      const void *ptr = dataspace::cptr(data);
      if(H5Awrite(static_cast<hid_t>(handle_),static_cast<hid_t>(mem_type),ptr)<0)
      {
        error::Singleton::instance().throw_with_stack("Failure to write data to attribute!");
      }
    }
 
    template<typename T>
    void read_fixed_length_string(T &data,
                                  const datatype::Datatype &mem_type) const
    {
      using Trait = FixedLengthStringTrait<T>;
      using SpaceTrait = hdf5::dataspace::TypeTrait<T>;
 
      auto buffer = Trait::BufferType::create(mem_type,SpaceTrait::create(data));
 
      if(H5Aread(static_cast<hid_t>(handle_),
                 static_cast<hid_t>(mem_type),
                 buffer.data())<0)
      {
        error::Singleton::instance().throw_with_stack("Failure to read data from attribute!");
      }
 
      data = Trait::from_buffer(buffer,mem_type,SpaceTrait::create(data));
 
    }
 
    void read_fixed_length_string(std::string &data,
                                  const datatype::Datatype &mem_type, bool trim = false) const
    {
      using Trait = FixedLengthStringTrait<std::string>;
      using SpaceTrait = hdf5::dataspace::TypeTrait<std::string>;
 
      auto buffer = Trait::BufferType::create(mem_type, SpaceTrait::create(data));
 
      if (H5Aread(static_cast<hid_t>(handle_),
                  static_cast<hid_t>(mem_type),
                  buffer.data()) < 0)
      {
        error::Singleton::instance().throw_with_stack("Failure to read data from attribute!");
      }
 
      if (trim)
      {
        data = Trait::from_buffer_trimmed(buffer, mem_type, SpaceTrait::create(data));
      }
      else
      {
        data = Trait::from_buffer(buffer, mem_type, SpaceTrait::create(data));
      }
    }
 
    template <typename T>
    void read_variable_length_string(T &data,
                                     const datatype::Datatype &mem_type) const
    {
      using Trait = VarLengthStringTrait<T>;
 
      typename Trait::BufferType buffer(signed2unsigned<typename std::vector<T>::size_type>(dataspace().size()));
 
      if(H5Aread(static_cast<hid_t>(handle_),
                 static_cast<hid_t>(mem_type),
                 buffer.data())<0)
      {
        error::Singleton::instance().throw_with_stack("Failure to read data from attribute!");
      }
 
      Trait::from_buffer(buffer,data);
 
      if(H5Dvlen_reclaim(static_cast<hid_t>(mem_type),
                         static_cast<hid_t>(dataspace()),
                         static_cast<hid_t>(property::DatasetTransferList()),
                         buffer.data())<0)
      {
        std::stringstream ss;
        ss<<"Failure to reclaim buffer for variable length string"
          <<" string read on attribute!";
        error::Singleton::instance().throw_with_stack(ss.str());
      }
 
    }
 
    template<typename T>
    void read_contiguous_data(T &data,
                              const datatype::Datatype &mem_type) const
    {
      void *ptr = dataspace::ptr(data);
 
      if(H5Aread(static_cast<hid_t>(handle_),static_cast<hid_t>(mem_type),ptr)<0)
      {
        error::Singleton::instance().throw_with_stack("Failure to read data from attribute!");
      }
    }
 
    void check_size(const dataspace::Dataspace &mem_space,
                    const dataspace::Dataspace &file_space,
                    const std::string &operation) const;
 
};
 
template<typename T>
void Attribute::write(const T &data,const datatype::Datatype &mem_type) const
{
  datatype::Datatype file_type = datatype();
 
  check_size(dataspace::create(data),dataspace(),"write");
 
  if(file_type.get_class()==datatype::Class::String)
  {
    datatype::String string_type(file_type);
 
    if(string_type.is_variable_length())
    {
      write_variable_length_string(data,mem_type);
    }
    else
    {
      write_fixed_length_string(data,mem_type);
    }
  }
  else
  {
    write_contiguous_data(data,mem_type);
  }
}
 
template<typename T>
void Attribute::write(const T &data) const
{
  auto file_type = datatype();
  if(file_type.get_class() == datatype::Class::String)
  {
    write(data,file_type);
  }
  else
  {
    hdf5::datatype::DatatypeHolder mem_type_holder;
    write(data,mem_type_holder.get<T>());
  }
}
 
template<typename T>
void Attribute::read(T &data) const
{
  auto file_type = datatype();
  if(file_type.get_class() == datatype::Class::String)
  {
    read(data, file_type);
  }
  else
  {
    hdf5::datatype::DatatypeHolder mem_type_holder;
    read(data, mem_type_holder.get<T>(), file_type);
  }
}
 
template<typename T>
void Attribute::read(T &data,const datatype::Datatype &mem_type) const
{
  datatype::Datatype file_type = datatype();
  read(data, mem_type, file_type);
}
 
template<typename T>
void Attribute::read(T &data, const datatype::Datatype &mem_type, const datatype::Datatype &file_type) const
{
  check_size(dataspace::create(data),dataspace(),"read");
 
  if(file_type.get_class()==datatype::Class::String)
  {
    datatype::String string_type(file_type);
 
    if(string_type.is_variable_length())
    {
      read_variable_length_string(data,mem_type);
    }
    else
    {
      read_fixed_length_string(data,mem_type);
    }
  }
  else
  {
    read_contiguous_data(data,mem_type);
  }
}
 
 
 
} // namespace attribute
} // namespace hdf5