hdf5/type.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_TYPE_HPP
#define ECHELON_HDF5_TYPE_HPP

#include <echelon/hdf5/precursor/type.hpp>

#include <string>
#include <vector>
#include <utility>

namespace echelon
{
namespace hdf5
{
class type_layout;

class type
{
public:
    using native_handle_type = hdf5::precursor::type;

    type() = default;
    
    explicit type(native_handle_type type_wrapper_);

    static type char_();

    static type short_();

    static type int_();

    static type long_();

    static type long_long();

    static type uchar();

    static type ushort();

    static type uint();

    static type ulong();

    static type ulong_long();

    static type float_();

    static type double_();

    static type string();

    static type object_reference();

    static type compound_type(const type_layout& layout);

    std::size_t size() const;

    type clone() const;

    const native_handle_type& native_handle() const;

    explicit operator bool() const;
private:
    hdf5::precursor::type type_wrapper_;
};

bool operator==(const type& lhs, const type& rhs);

bool operator!=(const type& lhs, const type& rhs);

class type_layout
{
public:
    struct element
    {
        element(std::string name, const type& type, std::size_t offset)
        : name(std::move(name)), type_(type.clone()), offset(offset)
        {
        }

        std::string name;

        type type_;

        std::size_t offset;
    };

    explicit type_layout(std::size_t size_) : size_(size_)
    {
    }

    void add_element(std::string name, const type& element_type, std::size_t offset)
    {
        elements_.emplace_back(name, element_type, offset);
    }

    typedef std::vector<element>::const_iterator iterator;

    iterator begin() const
    {
        using std::begin;

        return begin(elements_);
    }

    iterator end() const
    {
        using std::end;

        return end(elements_);
    }

    std::size_t size() const
    {
        return size_;
    }

private:
    std::vector<element> elements_;
    std::size_t size_;
};
}
}

#endif