FieldMap.h

Go to the documentation of this file.

//===-- serialbox/core/FieldMap.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_FIELDMAP_H
#define SERIALBOX_CORE_FIELDMAP_H

#include "serialbox/core/FieldMetainfoImpl.h"
#include "serialbox/core/Json.h"
#include <unordered_map>

namespace serialbox {


class FieldMap {
public:
  using map_type = std::unordered_map<std::string, std::shared_ptr<FieldMetainfoImpl>>;

  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;

  FieldMap() : map_(){};

  explicit FieldMap(const json::json jsonNode) { fromJSON(jsonNode); }

  FieldMap(const FieldMap&) = default;

  FieldMap(FieldMap&&) = default;

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

  FieldMap& operator=(FieldMap&&) = default;

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

  template <class StringType>
  iterator findField(StringType&& name) noexcept {
    return (map_.find(name));
  }

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

  template <class StringType>
  FieldMetainfoImpl& getFieldMetainfoImplOf(StringType&& name) {
    return *getFieldMetainfoImplPtrOf(std::forward<StringType>(name));
  }

  template <class StringType>
  const FieldMetainfoImpl& getFieldMetainfoImplOf(StringType&& name) const {
    return *getFieldMetainfoImplPtrOf(std::forward<StringType>(name));
  }

  template <class StringType>
  std::shared_ptr<FieldMetainfoImpl>& getFieldMetainfoImplPtrOf(StringType&& name) {
    iterator fieldIt = map_.find(name);
    if(fieldIt != map_.end())
      return fieldIt->second;
    throw Exception("field '%s' does not exist", name);
  }

  template <class StringType>
  const std::shared_ptr<FieldMetainfoImpl>& getFieldMetainfoImplPtrOf(StringType&& name) const {
    const_iterator fieldIt = map_.find(name);
    if(fieldIt != map_.end())
      return fieldIt->second;
    throw Exception("field '%s' does not exis", name);
  }

  template <class StringType>
  MetainfoMapImpl& getMetainfoOf(StringType&& name) {
    return getFieldMetainfoImplOf(name).metaInfo();
  }

  template <class StringType>
  const MetainfoMapImpl& getMetainfoOf(StringType&& name) const {
    return getFieldMetainfoImplOf(name).metaInfo();
  }

  template <class StringType>
  std::vector<int>& getDimsOf(StringType&& name) {
    iterator fieldIt = map_.find(name);
    if(fieldIt != map_.end())
      return fieldIt->second->dims();
    throw Exception("field '%s' does not exist in FieldMap", name);
  }

  template <class StringType>
  const std::vector<int>& getDimsOf(StringType&& name) const {
    const_iterator fieldIt = map_.find(name);
    if(fieldIt != map_.end())
      return fieldIt->second->dims();
    throw Exception("field '%s' does not exist in FieldMap", name);
  }

  template <class StringType>
  TypeID getTypeOf(StringType&& name) const {
    const_iterator fieldIt = map_.find(name);
    if(fieldIt != map_.end())
      return fieldIt->second->type();
    throw Exception("field '%s' does not exist in FieldMap", name);
  }

  template <class StringType, typename... Args>
  bool insert(StringType&& key, Args&&... args) {
    return map_.insert({key, std::make_shared<FieldMetainfoImpl>(std::forward<Args>(args)...)})
        .second;
  }

  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(FieldMap& other) noexcept { map_.swap(other.map_); }

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

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

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

  json::json toJSON() const;

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

private:
  map_type map_;
};


} // namespace serialbox

#endif