hdf5/attribute_repository.hpp

//  Copyright (c) 2012-2014 Christopher Hinz
//
//  Distributed under the Boost Software License, Version 1.0. (See accompanying
//  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

#ifndef ECHELON_HDF5_ATTRIBUTE_REPOSITORY_HPP
#define ECHELON_HDF5_ATTRIBUTE_REPOSITORY_HPP

#include <echelon/hdf5/type.hpp>
#include <echelon/hdf5/type_factory.hpp>
#include <echelon/hdf5/attribute.hpp>

#include <echelon/hdf5/broken_contract_exception.hpp>

#include <memory>
#include <map>
#include <string>
#include <exception>
#include <utility>

namespace echelon
{
namespace hdf5
{
class non_existing_attribute_exception : public std::exception
{
public:
    non_existing_attribute_exception(std::string what_) : what_(std::move(what_))
    {
    }

    ~non_existing_attribute_exception() noexcept
    {
    }

    const char* what() const noexcept override
    {
        return what_.c_str();
    }

private:
    std::string what_;
};

template <typename Parent>
class attribute_repository
{
public:
    explicit attribute_repository(Parent parent_) : parent_(std::move(parent_))
    {
    }

    attribute create(const std::string& name, const type& datatype)
    {
        return attribute(object(parent_), name, datatype);
    }

    template <typename T>
    attribute create(const std::string& name)
    {
        return create(name, get_hdf5_type<T>());
    }

    template <typename T>
    attribute create(const std::string& name, const T& value)
    {
        attribute attr = create<T>(name);

        attr <<= value;

        return attr;
    }

    attribute operator[](const std::string& name) const
    {
        return attribute(object(parent_), name);
    }

    bool exists(const std::string& name) const
    {
        return hdf5::precursor::is_attribute_existing(hdf5::precursor::object(parent_.id()), name);
    }

    attribute require(const std::string& name, const type& datatype)
    {
        if (exists(name))
        {
            attribute attr(object(parent_), name);

            if (attr.datatype() != datatype)
                throw broken_contract_exception("The required datatype doesn't "
                                                "match the datatype of the attribute.");

            return attr;
        }
        else
        {
            return create(name, datatype);
        }
    }

    template <typename T>
    attribute require(const std::string& name)
    {
        return require(name, get_hdf5_type<T>());
    }

    template <typename T>
    attribute require(const std::string& name, const T& value)
    {
        type datatype = get_hdf5_type<T>();

        if (exists(name))
        {
            attribute attr(object(parent_), name);

            if (attr.datatype() != datatype)
                throw broken_contract_exception("The required datatype doesn't "
                                                "match the datatype of the attribute.");

            return attr;
        }
        else
        {
            attribute attr = create(name, datatype);

            attr <<= value;

            return attr;
        }
    }

private:
    Parent parent_;
};
}
}

#endif