MetainfoMapImpl.h

Go to the documentation of this file.

//===-- serialbox/core/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_METAINFOMAPIMPL_H
#define SERIALBOX_CORE_METAINFOMAPIMPL_H

#include "serialbox/core/Exception.h"
#include "serialbox/core/Json.h"
#include "serialbox/core/MetainfoValueImpl.h"
#include "serialbox/core/Type.h"
#include <iosfwd>
#include <string>
#include <unordered_map>
#include <utility>
#include <vector>

namespace serialbox {


class MetainfoMapImpl {
public:
  using map_type = std::unordered_map<std::string, MetainfoValueImpl>;

  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;

  MetainfoMapImpl() : map_(){};

  explicit MetainfoMapImpl(const json::json& jsonNode) { fromJSON(jsonNode); }

  explicit MetainfoMapImpl(std::initializer_list<value_type> list) : map_(list){};

  MetainfoMapImpl(const MetainfoMapImpl&) = default;

  MetainfoMapImpl(MetainfoMapImpl&&) = default;

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

  MetainfoMapImpl& operator=(MetainfoMapImpl&&) = default;

  template <class StringType>
  bool hasKey(StringType&& key) const noexcept {
    return (map_.find(key) != map_.end());
  }

  std::vector<std::string> keys() const;

  std::vector<TypeID> types() const;

  template <class StringType>
  iterator find(StringType&& key) noexcept {
    return map_.find(key);
  }
  template <class StringType>
  const_iterator find(StringType&& key) const noexcept {
    return map_.find(key);
  }

  template <class KeyType, class ValueType>
  bool insert(KeyType&& key, ValueType&& value) noexcept {
    return (map_.insert({key, MetainfoValueImpl(std::forward<ValueType>(value))}).second);
  }

  template <class ValueType, class KeyType>
  ValueType as(KeyType&& key) const {
    return at(key).template as<ValueType>();
  }

  iterator erase(const_iterator position) { return map_.erase(position); }
  size_type erase(const key_type& key) { return map_.erase(key); }
  iterator erase(const_iterator first, const_iterator last) { return map_.erase(first, last); }

  mapped_type& operator[](const key_type& key) noexcept { return map_[key]; }
  mapped_type& operator[](key_type&& key) noexcept { return map_[key]; }

  mapped_type& at(const key_type& key);
  const mapped_type& at(const key_type& key) const;

  std::size_t size() const noexcept { return map_.size(); }

  bool empty() const noexcept { return map_.empty(); }

  void clear() noexcept { map_.clear(); }

  iterator begin() noexcept { return map_.begin(); }
  const_iterator begin() const noexcept { return map_.begin(); }

  iterator end() noexcept { return map_.end(); }
  const_iterator end() const noexcept { return map_.end(); }

  void swap(MetainfoMapImpl& other) noexcept { map_.swap(other.map_); }

  bool operator==(const MetainfoMapImpl& right) const noexcept { return (map_ == right.map_); }

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

  json::json toJSON() const;

  void fromJSON(const json::json& jsonNode);

  friend std::ostream& operator<<(std::ostream& stream, const MetainfoMapImpl& s);

private:
  map_type map_;
};


} // namespace serialbox

#endif