SerializerImpl.h

Go to the documentation of this file.

//===-- serialbox/core/SerializerImpl.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_SERIALIZERIMPL_H
#define SERIALBOX_CORE_SERIALIZERIMPL_H

#include "serialbox/core/FieldMap.h"
#include "serialbox/core/Filesystem.h"
#include "serialbox/core/Json.h"
#include "serialbox/core/MetainfoMapImpl.h"
#include "serialbox/core/SavepointVector.h"
#include "serialbox/core/StorageView.h"
#include "serialbox/core/archive/Archive.h"
#include <iosfwd>

namespace serialbox {


class SerializerImpl {
public:
  static int serializationStatus() noexcept { return enabled_; }

  static void enableSerialization() noexcept { enabled_ = 1; }

  static void disableSerialization() noexcept { enabled_ = -1; }

  SerializerImpl(const SerializerImpl&) = delete;

  SerializerImpl(SerializerImpl&&) = default;

  SerializerImpl& operator=(const SerializerImpl&) = delete;

  SerializerImpl& operator=(SerializerImpl&&) = default;

  SerializerImpl(OpenModeKind mode, const std::string& directory, const std::string& prefix,
                 const std::string& archiveName);

  OpenModeKind mode() const noexcept { return mode_; }

  const filesystem::path& directory() const noexcept { return directory_; }

  std::string prefix() const noexcept { return prefix_; }

  std::string archiveName() const noexcept { return archive_->name(); }

  const filesystem::path& metaDataFile() const noexcept { return metaDataFile_; }

  void clear() noexcept;

  //===----------------------------------------------------------------------------------------===//
  //     Global Meta-Information
  //===----------------------------------------------------------------------------------------===//

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

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

  MetainfoMapImpl& globalMetainfo() noexcept { return *globalMetainfo_; }
  const MetainfoMapImpl& globalMetainfo() const noexcept { return *globalMetainfo_; }

  std::shared_ptr<MetainfoMapImpl>& globalMetainfoPtr() noexcept { return globalMetainfo_; }
  const std::shared_ptr<MetainfoMapImpl>& globalMetainfoPtr() const noexcept {
    return globalMetainfo_;
  }

  //===----------------------------------------------------------------------------------------===//
  //     Register and Query Fields
  //===----------------------------------------------------------------------------------------===//

  template <class StringType, typename... Args>
  void registerField(StringType&& name, Args&&... args) {
    if(!fieldMap_->insert(std::forward<StringType>(name), std::forward<Args>(args)...))
      throw Exception("cannot register field '%s': field already exists", name);
  }

  template <class StringType>
  bool hasField(StringType&& name) const noexcept {
    return fieldMap_->hasField(std::forward<StringType>(name));
  }

  template <class StringType, class KeyType, class ValueType>
  bool addFieldMetainfoImpl(StringType&& name, KeyType&& key, ValueType&& value) {
    return fieldMap_->getMetainfoOf(name).insert(std::forward<KeyType>(key),
                                                 std::forward<ValueType>(value));
  }

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

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

  FieldMap& fieldMap() noexcept { return *fieldMap_; }
  const FieldMap& fieldMap() const noexcept { return *fieldMap_; }

  std::shared_ptr<FieldMap>& fieldMapPtr() noexcept { return fieldMap_; }
  const std::shared_ptr<FieldMap>& fieldMapPtr() const noexcept { return fieldMap_; }

  //===----------------------------------------------------------------------------------------===//
  //     Register and Query Savepoints
  //===----------------------------------------------------------------------------------------===//

  template <typename... Args>
  bool registerSavepoint(Args&&... args) noexcept {
    return (savepointVector_->insert(SavepointImpl(std::forward<Args>(args)...)) != -1);
  }

  bool addFieldToSavepoint(const SavepointImpl& savepoint, const FieldID& fieldID) noexcept {
    return savepointVector_->addField(savepoint, fieldID);
  }

  FieldID getFieldIDAtSavepoint(const SavepointImpl& savepoint, const std::string& field) const {
    return savepointVector_->getFieldID(savepoint, field);
  }

  const SavepointVector::savepoint_vector_type& savepoints() const noexcept {
    return savepointVector_->savepoints();
  }
  SavepointVector::savepoint_vector_type& savepoints() noexcept {
    return savepointVector_->savepoints();
  }

  const SavepointVector& savepointVector() const noexcept { return *savepointVector_; }
  SavepointVector& savepointVector() noexcept { return *savepointVector_; }

  const std::shared_ptr<SavepointVector>& savepointVectorPtr() const noexcept {
    return savepointVector_;
  }
  std::shared_ptr<SavepointVector>& savepointVectorPtr() noexcept { return savepointVector_; }

  //===----------------------------------------------------------------------------------------===//
  //     Writing
  //===----------------------------------------------------------------------------------------===//

  void write(const std::string& name, const SavepointImpl& savepoint,
             const StorageView& storageView);

  //===----------------------------------------------------------------------------------------===//
  //     Reading
  //===----------------------------------------------------------------------------------------===//

  void read(const std::string& name, const SavepointImpl& savepoint, StorageView& storageView, bool alsoPrevious = false);

  void readSliced(const std::string& name, const SavepointImpl& savepoint, StorageView& storageView,
                  Slice slice);

  void readAsync(const std::string& name, const SavepointImpl& savepoint, StorageView& storageView);

  void waitForAll();

  //===----------------------------------------------------------------------------------------===//
  //     JSON Serialization
  //===----------------------------------------------------------------------------------------===//

  void updateMetaData();

  json::json toJSON() const;

  std::string toString() const;

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

protected:
  void constructMetaDataFromJson();

  void constructArchive(const std::string& archiveName);

  std::shared_ptr<FieldMetainfoImpl> checkStorageView(const std::string& name,
                                                      const StorageView& storageView) const;

  bool upgradeMetaData();

  void readAsyncImpl(const std::string name, const SavepointImpl savepoint,
                     StorageView storageView);

protected:
  OpenModeKind mode_;
  filesystem::path directory_;
  filesystem::path metaDataFile_;
  std::string prefix_;

  std::shared_ptr<SavepointVector> savepointVector_;
  std::shared_ptr<FieldMap> fieldMap_;
  std::shared_ptr<MetainfoMapImpl> globalMetainfo_;

  std::unique_ptr<Archive> archive_;

  // This variable can take three values:
  //
  //  0: the variable is not yet initialized -> the serialization is enabled if the environment
  //     variable SERIALBOX_SERIALIZATION_DISABLE is not set to  a positive value. The first
  //     serializer which is initialized has to set this value either to +1 or to -1 according to
  //     the environment.
  // +1: the serialization is enabled, independently of the environment
  // -1: the serialization is disabled, independently of the environment
  //
  // The value is initialized to 0
  static int enabled_;
};


} // namespace serialbox

#endif