Value.h

Go to the documentation of this file.

// SPDX-License-Identifier: Apache-2.0
// Copyright 2022 Stéphane Caron
// Copyright 2024 Inria
/*
 * This file incorporates work covered by the following copyright and
 * permission notice:
 *
 *     Configuration and DataStore classes of mc_rtc
 *     Copyright 2015-2020 CNRS-UM LIRMM, CNRS-AIST JRL
 *     SPDX-License-Identifier: BSD-2-Clause
 */
 
#pragma once
 
#include <functional>
#include <memory>
#include <stdexcept>
#include <string>
#include <typeinfo>
 
#include "palimpsest/exceptions/TypeError.h"
#include "palimpsest/internal/Allocator.h"
#include "palimpsest/internal/is_valid_hash.h"
#include "palimpsest/internal/type_name.h"
#include "palimpsest/json/write.h"
#include "palimpsest/mpack/Writer.h"
#include "palimpsest/mpack/read.h"
#include "palimpsest/mpack/write.h"
 
namespace palimpsest {
 
using exceptions::TypeError;
 
class Value {
 public:
  Value() = default;
 
  Value(const Value &other) {
    if (other.buffer) {
      other.copy_(*this, other);
    }
  }
 
  Value &operator=(const Value &other) {
    if (this != &other) {
      // Clean up existing buffer if any
      if (this->buffer) {
        destroy_(*this);
        this->buffer = nullptr;
      }
 
      // Copy from other if it has data
      if (other.buffer) {
        other.copy_(*this, other);
      }
    }
    return *this;
  }
 
  Value(Value &&) = default;
 
  Value &operator=(Value &&) = default;
 
  ~Value() {
    if (this->buffer) {
      destroy_(*this);
    }
  }
 
  template <typename T>
  void allocate() {
    this->buffer.reset(
        reinterpret_cast<uint8_t *>(internal::Allocator<T>().allocate(1)));
  }
 
  void deserialize(mpack_node_t node) { deserialize_(*this, node); }
 
  void print(std::ostream &stream) const { print_(*this, stream); }
 
  void serialize(mpack::Writer &writer) const {
    serialize_(*this, writer.mpack_writer());
  }
 
  template <typename T, typename... ArgsT>
  T &setup() {
    this->type_name = &internal::type_name<T>;
    this->same = &internal::is_valid_hash<T, ArgsT...>;
    copy_ = [](Value &dest, const Value &src) {
      dest.allocate<T>();
      dest.type_name = src.type_name;
      dest.same = src.same;
      dest.deserialize_ = src.deserialize_;
      dest.destroy_ = src.destroy_;
      dest.print_ = src.print_;
      dest.serialize_ = src.serialize_;
      dest.copy_ = src.copy_;
      const T *src_obj = reinterpret_cast<const T *>(src.buffer.get());
      new (dest.buffer.get()) T(*src_obj);
    };
    deserialize_ = [](Value &self, mpack_node_t node) {
      T *cast_buffer = reinterpret_cast<T *>(self.buffer.get());
      mpack::read<T>(node, *cast_buffer);
    };
    destroy_ = [](Value &self) {
      T *p = reinterpret_cast<T *>(self.buffer.release());
      p->~T();
      internal::Allocator<T>().deallocate(p, 1);
    };
    print_ = [](const Value &self, std::ostream &stream) {
      const T *cast_buffer = reinterpret_cast<const T *>(self.buffer.get());
      json::write<T>(stream, *cast_buffer);
    };
    serialize_ = [](const Value &self, mpack_writer_t *writer) {
      const T *cast_buffer = reinterpret_cast<const T *>(self.buffer.get());
      mpack::write<T>(writer, *cast_buffer);
    };
    return *(reinterpret_cast<T *>(this->buffer.get()));
  }
 
  template <typename T>
  T &get_reference() const {
    if (!this->same(typeid(T).hash_code())) {
      std::string cast_type = this->type_name();
      throw TypeError(__FILE__, __LINE__,
                      "Object has type \"" + cast_type +
                          "\" but is being cast to type \"" + typeid(T).name() +
                          "\".");
    }
    return *(reinterpret_cast<T *>(this->buffer.get()));
  }
 
 public:
  std::unique_ptr<uint8_t[]> buffer = nullptr;
 
  const char *(*type_name)();
 
  bool (*same)(std::size_t);
 
 private:
  void (*copy_)(Value &, const Value &);
 
  void (*deserialize_)(Value &, mpack_node_t);
 
  void (*destroy_)(Value &);
 
  void (*print_)(const Value &, std::ostream &);
 
  void (*serialize_)(const Value &, mpack_writer_t *);
};
 
}  // namespace palimpsest