SavepointImpl.h

Go to the documentation of this file.

//===-- serialbox/core/SavepointImpl.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_SAVEPOINTIMPL_H
#define SERIALBOX_CORE_SAVEPOINTIMPL_H

#include "serialbox/core/Exception.h"
#include "serialbox/core/Json.h"
#include "serialbox/core/MetainfoMapImpl.h"
#include <functional>
#include <iosfwd>
#include <string>
#include <utility>

namespace serialbox {


class SavepointImpl {
public:
  template <class StringType,
            class = typename std::enable_if<!std::is_same<StringType, json::json>::value>::type>
  explicit SavepointImpl(const StringType& name)
      : name_(name), metaInfo_(std::make_shared<MetainfoMapImpl>()) {}

  template <class StringType, class MetainfoType>
  SavepointImpl(StringType&& name, MetainfoType&& metaInfo)
      : name_(name),
        metaInfo_(std::make_shared<MetainfoMapImpl>(std::forward<MetainfoType>(metaInfo))) {}

  SavepointImpl(const SavepointImpl& other) { *this = other; }

  SavepointImpl(SavepointImpl&&) = default;

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

  SavepointImpl& operator=(const SavepointImpl& other);

  SavepointImpl& operator=(SavepointImpl&&) = default;

  template <class StringType, class ValueType>
  void addMetainfo(StringType&& key, ValueType&& value) {
    if(!metaInfo_->insert(std::forward<StringType>(key), std::forward<ValueType>(value)))
      throw Exception("cannot add element with key '%s' to metaInfo: element already exists", key);
  }

  template <class T, class StringType>
  T getMetainfoAs(StringType&& key) const {
    try {
      return metaInfo_->at(key).template as<T>();
    } catch(Exception& e) {
      throw Exception("cannot get element with key '%s' from metaInfo: %s", key, e.what());
    }
  }

  bool operator==(const SavepointImpl& right) const {
    return (name_ == right.name_) && (*metaInfo_ == *right.metaInfo_);
  }

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

  void swap(SavepointImpl& other) noexcept {
    name_.swap(other.name_);
    metaInfo_->swap(*other.metaInfo_);
  }

  const std::string& name() const noexcept { return name_; }

  MetainfoMapImpl& metaInfo() noexcept { return *metaInfo_; }
  const MetainfoMapImpl& metaInfo() const noexcept { return *metaInfo_; }

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

  json::json toJSON() const;

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

  std::string toString() const;

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

  std::shared_ptr<MetainfoMapImpl>& metaInfoPtr() noexcept { return metaInfo_; }
  const std::shared_ptr<MetainfoMapImpl>& metaInfoPtr() const noexcept { return metaInfo_; }

private:
  std::string name_;                          
  std::shared_ptr<MetainfoMapImpl> metaInfo_; 
};


} // namespace serialbox

namespace std {

template <>
struct hash<serialbox::SavepointImpl> {
  std::size_t operator()(const serialbox::SavepointImpl& s) const noexcept {
    return std::hash<std::string>()(s.name());
  }
};

} // namespace std

#endif