attribute_manager.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 <string>
#include <h5cpp/attribute/attribute.hpp>
#include <h5cpp/core/types.hpp>
#include <h5cpp/core/windows.hpp>
#include <h5cpp/core/iterator_config.hpp>
#include <h5cpp/datatype/factory.hpp>
#include <h5cpp/dataspace/scalar.hpp>
#include <h5cpp/dataspace/simple.hpp>
#include <h5cpp/property/attribute_creation.hpp>
 
//
// forward declarations
//
namespace hdf5 {
namespace node {
 
class Node;
 
} // namespace node
} // namespace hdf5
 
namespace hdf5 {
namespace attribute {
 
//forward declaration
class AttributeIterator;
 
class DLL_EXPORT AttributeManager
{
  public:
    AttributeManager() = delete;
 
    AttributeManager(node::Node &node);
 
    AttributeManager(const AttributeManager &manager) = default;
 
    Attribute operator[](size_t index) const;
 
    Attribute operator[](const std::string &name) const;
 
    size_t size() const;
 
    void remove(const std::string &name) const;
 
    void remove(size_t index) const;
 
    bool exists(const std::string &name) const;
 
    void rename(const std::string &old_name,const std::string &new_name) const;
 
    Attribute create(const std::string &name,
                     const datatype::Datatype &datatype,
                     const dataspace::Dataspace &dataspace,
                     const property::AttributeCreationList &acpl =
                           property::AttributeCreationList()) const;
 
    template<typename T>
    Attribute create(const std::string &name,
                     const property::AttributeCreationList &acpl =
                           property::AttributeCreationList()) const;
 
    template<typename T>
    Attribute create(const std::string &name,const Dimensions &shape,
                     const property::AttributeCreationList &acpl =
                           property::AttributeCreationList()) const;
 
    template<typename T>
    Attribute create_from(const std::string &name,const T &value);
 
    IteratorConfig &iterator_config() noexcept;
    const IteratorConfig &iterator_config() const noexcept;
 
    const node::Node &node() const noexcept;
 
    AttributeIterator begin() const;
 
    AttributeIterator end() const;
 
  private:
    node::Node &node_;
    IteratorConfig iter_config_;
 
 
};
 
template<typename T>
Attribute AttributeManager::create(const std::string &name,
                                   const property::AttributeCreationList &acpl) const
{
  hdf5::datatype::DatatypeHolder mem_type_holder;
  dataspace::Scalar space;
 
  return this->create(name,mem_type_holder.get<T>(),space,acpl);
}
 
template<typename T>
Attribute AttributeManager::create(const std::string &name,
                                   const Dimensions &shape,
                                   const property::AttributeCreationList &acpl) const
{
  hdf5::datatype::DatatypeHolder mem_type_holder;
  dataspace::Simple space(shape);
 
  return create(name,mem_type_holder.get<T>(),space,acpl);
 
}
 
template<typename T>
Attribute AttributeManager::create_from(const std::string &name,const T &value)
{
  hdf5::datatype::DatatypeHolder mem_type_holder;
  auto space = dataspace::create(value);
 
  Attribute a = create(name,mem_type_holder.get<T>(),space);
  a.write(value);
  return a;
}
 
} // namespace attribute
} // namespace hdf5