MetainfoMap.h

Go to the documentation of this file.

//===-- serialbox/core/frontend/gridtools/MetainfoMapImpl.h -------------------------*- C++ -*-===//
//
//                                    S E R I A L B O X
//
// This file is distributed under terms of BSD license.
// See LICENSE.txt for more information
//
//===------------------------------------------------------------------------------------------===//
//
//===------------------------------------------------------------------------------------------===//

#ifndef SERIALBOX_CORE_FRONTEND_GRIDTOOLS_META_INFO_MAP_H
#define SERIALBOX_CORE_FRONTEND_GRIDTOOLS_META_INFO_MAP_H

#include "serialbox/core/MetainfoMapImpl.h"
#include "serialbox/core/frontend/gridtools/Exception.h"
#include "serialbox/core/frontend/gridtools/MetainfoValue.h"
#include <memory>

namespace serialbox {

namespace gridtools {

class meta_info_map {
public:
  using map_type = MetainfoMapImpl::map_type;

  using value_type = map_type::value_type;

  using key_type = map_type::key_type;

  using mapped_type = map_type::mapped_type;

  using size_type = map_type::size_type;

  using iterator = map_type::iterator;

  using const_iterator = map_type::const_iterator;

  meta_info_map() : map_impl_(std::make_shared<MetainfoMapImpl>()) {}

  meta_info_map(std::initializer_list<value_type> list)
      : map_impl_(std::make_shared<MetainfoMapImpl>(list)) {}

  meta_info_map(const meta_info_map&) = default;

  meta_info_map(meta_info_map&&) = default;

  meta_info_map& operator=(const meta_info_map&) = default;

  meta_info_map& operator=(meta_info_map&&) = default;

  meta_info_map& operator=(std::initializer_list<value_type> list) {
    map_impl_ = std::make_shared<MetainfoMapImpl>(list);
    return (*this);
  }

  meta_info_map clone() const {
    return meta_info_map(std::make_shared<MetainfoMapImpl>(*map_impl_));
  }

  explicit meta_info_map(const std::shared_ptr<MetainfoMapImpl>& map) { map_impl_ = map; }

  template <class StringType>
  bool has_key(StringType&& key) const noexcept {
    return map_impl_->hasKey(std::forward<StringType>(key));
  }

  std::vector<std::string> keys() const { return map_impl_->keys(); }

  std::vector<TypeID> types() const { return map_impl_->types(); }

  template <class StringType>
  iterator find(StringType&& key) noexcept {
    return map_impl_->find(std::forward<StringType>(key));
  }
  template <class StringType>
  const_iterator find(StringType&& key) const noexcept {
    return map_impl_->find(std::forward<StringType>(key));
  }

  template <class KeyType, class ValueType>
  bool insert(KeyType&& key, ValueType&& value) noexcept {
    return map_impl_->insert(std::forward<KeyType>(key), std::forward<ValueType>(value));
  }

  template <class ValueType, class KeyType>
  ValueType as(KeyType&& key) const {
    return map_impl_->at(std::forward<KeyType>(key)).template as<ValueType>();
  }

  iterator erase(const_iterator position) { return map_impl_->erase(position); }
  size_type erase(const key_type& key) { return map_impl_->erase(key); }
  iterator erase(const_iterator first, const_iterator last) {
    return map_impl_->erase(first, last);
  }

  mapped_type& operator[](const key_type& key) noexcept { return map_impl_->operator[](key); }
  mapped_type& operator[](key_type&& key) noexcept { return map_impl_->operator[](key); }

  mapped_type& at(const key_type& key) { return map_impl_->at(key); }
  const mapped_type& at(const key_type& key) const { return map_impl_->at(key); }

  std::size_t size() const noexcept { return map_impl_->size(); }

  bool empty() const noexcept { return map_impl_->empty(); }

  void clear() noexcept { map_impl_->clear(); }

  iterator begin() noexcept { return map_impl_->begin(); }
  const_iterator begin() const noexcept { return map_impl_->begin(); }

  iterator end() noexcept { return map_impl_->end(); }
  const_iterator end() const noexcept { return map_impl_->end(); }

  void swap(meta_info_map& other) noexcept { map_impl_->swap(*other.map_impl_); }

  bool operator==(const meta_info_map& right) const noexcept {
    return (*map_impl_ == *right.map_impl_);
  }

  bool operator!=(const meta_info_map& right) const noexcept { return (!(*this == right)); }

  friend std::ostream& operator<<(std::ostream& stream, const meta_info_map& s) {
    return (stream << *s.map_impl_);
  }

  const std::shared_ptr<MetainfoMapImpl>& impl() const { return map_impl_; }

private:
  std::shared_ptr<MetainfoMapImpl> map_impl_;
};

} // namespace gridtools

} // namespace serialbox

#endif