SavepointVector.h

Go to the documentation of this file.

//===-- serialbox/core/SavepointVector.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_SAVEPOINTVECTOR_H
#define SERIALBOX_CORE_SAVEPOINTVECTOR_H

#include "serialbox/core/FieldID.h"
#include "serialbox/core/Json.h"
#include "serialbox/core/SavepointImpl.h"
#include <iosfwd>
#include <unordered_map>
#include <vector>

namespace serialbox {


class SavepointVector {
  using index_type = std::unordered_map<SavepointImpl, int>;

public:
  using savepoint_vector_type = std::vector<std::shared_ptr<SavepointImpl>>;

  using fields_per_savepoint_type = std::unordered_map<std::string, unsigned int>;

  using fields_per_savepoint_vector_type = std::vector<fields_per_savepoint_type>;

  using iterator = savepoint_vector_type::iterator;

  using const_iterator = savepoint_vector_type::const_iterator;

  SavepointVector() : index_(), savepoints_(), fields_(){};

  SavepointVector(const SavepointVector&) = default;

  SavepointVector(SavepointVector&&) = default;

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

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

  SavepointVector& operator=(SavepointVector&&) = default;

  bool exists(const SavepointImpl& savepoint) const noexcept;

  int find(const SavepointImpl& savepoint) const noexcept;

  int insert(const SavepointImpl& savepoint) noexcept;

  bool addField(const SavepointImpl& savepoint, const FieldID& fieldID) noexcept;

  bool addField(int idx, const FieldID& fieldID) noexcept;

  bool hasField(const SavepointImpl& savepoint, const std::string& field) noexcept;

  bool hasField(int idx, const std::string& field) noexcept;

  FieldID getFieldID(const SavepointImpl& savepoint, const std::string& field) const;

  FieldID getFieldID(int idx, const std::string& field) const;

  const fields_per_savepoint_type& fieldsOf(const SavepointImpl& savepoint) const;

  const fields_per_savepoint_type& fieldsOf(int idx) const noexcept;

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

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

  void clear() noexcept;

  void swap(SavepointVector& other) noexcept;

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

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

  SavepointImpl& operator[](int idx) noexcept { return *savepoints_[idx]; }
  const SavepointImpl& operator[](int idx) const noexcept { return *savepoints_[idx]; }

  std::shared_ptr<SavepointImpl>& back() noexcept { return savepoints_.back(); }
  const std::shared_ptr<SavepointImpl>& back() const noexcept { return savepoints_.back(); }

  const savepoint_vector_type& savepoints() const noexcept { return savepoints_; }
  savepoint_vector_type& savepoints() noexcept { return savepoints_; }

  json::json toJSON() const;

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

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

private:
  index_type index_;                        
  savepoint_vector_type savepoints_;        
  fields_per_savepoint_vector_type fields_; 
};


} // namespace serialbox

#endif