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
// ===========================================================================
//
// Author: Eugen Wintersberger <eugen.wintersberger@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
{
  auto type = datatype::create<T>();
  dataspace::Scalar space;

  return this->create(name,type,space,acpl);
}

template<typename T>
Attribute AttributeManager::create(const std::string &name,
                                   const Dimensions &shape,
                                   const property::AttributeCreationList &acpl) const
{
  auto type = datatype::create<T>();
  dataspace::Simple space(shape);

  return create(name,type,space,acpl);

}

template<typename T>
Attribute AttributeManager::create_from(const std::string &name,const T &value)
{
  auto type = datatype::create<T>();
  auto space = dataspace::create(value);

  Attribute a = create(name,type,space);
  a.write(value);
  return a;
}

} // namespace attribute
} // namespace hdf5