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>

namespace hdf5 {
namespace attribute {

class DLL_EXPORT Attribute
{
  public:
    Attribute(ObjectHandle &&handle,const node::Link &parent_link);

    Attribute() = default;

    Attribute(const 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;

  private:
    ObjectHandle handle_;
    node::Link   parent_link_;

    template<typename T>
    void read(T &data,const datatype::Datatype &mem_type, const datatype::Datatype &file_type) 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));

    }

    template<typename T>
    void read_variable_length_string(T &data,
                                     const datatype::Datatype &mem_type) const
    {
      using Trait = VarLengthStringTrait<T>;

      typename Trait::BufferType buffer(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 mem_type = datatype::create<T>(data);

  write(data,mem_type);
}

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
  {
    auto mem_type = datatype::create<T>(data);
    read(data, mem_type, 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