BinaryArchive.h

Go to the documentation of this file.

//===-- serialbox/core/archive/BinaryArchive.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_ARCHIVE_BINARYARCHIVE_H
#define SERIALBOX_CORE_ARCHIVE_BINARYARCHIVE_H

#include "serialbox/core/Compiler.h"
#include "serialbox/core/Filesystem.h"
#include "serialbox/core/Json.h"
#include "serialbox/core/archive/Archive.h"
#include "serialbox/core/hash/Hash.h"
#include <string>
#include <unordered_map>
#include <vector>

namespace serialbox {

class BinaryArchive : public Archive {
public:
  static const std::string Name;

  static const int Version;

  struct FileOffsetType {
    std::streamoff offset; 
    std::string checksum;  
  };

  using FieldOffsetTable = std::vector<FileOffsetType>;

  using FieldTable = std::unordered_map<std::string, FieldOffsetTable>;

  BinaryArchive();

  BinaryArchive(OpenModeKind mode, const std::string& directory, const std::string& prefix,
                bool skipMetaData = false);

  BinaryArchive(const BinaryArchive&) = delete;

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

  virtual ~BinaryArchive();

  void readMetaDataFromJson();

  void writeMetaDataToJson();

  virtual FieldID write(const StorageView& storageView, const std::string& fieldID,
                        const std::shared_ptr<FieldMetainfoImpl> info) override;

  virtual void read(StorageView& storageView, const FieldID& fieldID,
                    std::shared_ptr<FieldMetainfoImpl> info) const override;

  virtual void updateMetaData() override;

  virtual OpenModeKind mode() const override { return mode_; }

  virtual std::string directory() const override { return directory_.string(); }

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

  virtual std::string name() const override { return BinaryArchive::Name; }

  virtual std::string metaDataFile() const override { return metaDatafile_.string(); }

  virtual std::ostream& toStream(std::ostream& stream) const override;

  virtual void clear() override;

  virtual bool isReadingThreadSafe() const override { return true; }

  virtual bool isWritingThreadSafe() const override { return false; }

  virtual bool isSlicedReadingSupported() const override { return true; }


  void clearFieldTable();

  static std::unique_ptr<Archive> create(OpenModeKind mode, const std::string& directory,
                                         const std::string& prefix);

  FieldTable& fieldTable() noexcept { return fieldTable_; }
  const FieldTable& fieldTable() const noexcept { return fieldTable_; }

  static void writeToFile(std::string filename, const StorageView& storageView);

  static void readFromFile(std::string filename, StorageView& storageView);

  void setHash(std::unique_ptr<Hash> hash) noexcept { hash_ = std::move(hash); }

  const std::unique_ptr<Hash>& hash() const noexcept { return hash_; }

private:
  OpenModeKind mode_;
  filesystem::path directory_;
  std::string prefix_;

  filesystem::path metaDatafile_;
  std::unique_ptr<Hash> hash_;
  json::json json_;
  FieldTable fieldTable_;
};

} // namespace serialbox

#endif