core_types.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <atomic>
#include <nlohmann/json.hpp>
#include <toast/export.hpp>
#include <toast/uid.hpp>
#include <toml++/toml.hpp>
#include <vector>
 
using json_t = nlohmann::json;
 
namespace assets {
// clang-format off
enum class SaveMode : uint8_t {
  editor,    
  game,      
};

class TOAST_API ISaveable {
public:
  [[nodiscard]]
  virtual auto serialize(SaveMode mode) const -> std::vector<uint8_t> = 0;
  virtual ~ISaveable() = default;
};
 
// clang-format on

class TOAST_API Asset {
public:
  Asset() = default;
  virtual ~Asset() = default;
 
  Asset(const Asset&) = delete;
  auto operator=(const Asset&) -> Asset& = delete;
 
  [[nodiscard]]
  auto refCount() const noexcept -> uint32_t;
 
  [[nodiscard]]
  virtual auto type() const -> std::string_view = 0;
 
protected:
  void addRef() noexcept;
  void release() noexcept;
 
  friend class HandleBase;
 
private:
  std::atomic<uint32_t> m_ref_count {0};    
};

class TOAST_API HandleBase {
public:
  HandleBase() = default;
  explicit HandleBase(Asset* asset);

  HandleBase(Asset* asset, toast::UID uid, std::string_view uri);
 
  virtual ~HandleBase();
 
  HandleBase(const HandleBase& other);
  auto operator=(const HandleBase& other) -> HandleBase&;
 
  HandleBase(HandleBase&& other) noexcept;
  auto operator=(HandleBase&& other) noexcept -> HandleBase&;

  void onChangeCallback(std::function<void()>&& callback);
 
  [[nodiscard]]
  auto hasValue() const noexcept -> bool;
 
  [[nodiscard]]
  auto uid() const noexcept -> toast::UID {
    return m_uid;
  }
 
  [[nodiscard]]
  auto path() const noexcept -> std::string_view {
    return m_uri;
  }
 
  [[nodiscard]]
  auto get() noexcept -> Asset&;
 
  [[nodiscard]]
  auto get() const noexcept -> const Asset&;
 
  [[nodiscard]]
  auto operator->() noexcept -> Asset*;
 
  [[nodiscard]]
  auto operator->() const noexcept -> const Asset*;
 
  [[nodiscard]]
  auto operator==(const HandleBase& other) const -> bool {
    return m_uid.data() == other.m_uid.data();
  }
 
  [[nodiscard]]
  auto operator<(const HandleBase& other) const -> bool {
    return m_uid.data() < other.m_uid.data();
  }
 
protected:
  Asset* m_asset = nullptr;
  toast::UID m_uid;
  std::string m_uri;
 
private:
  std::vector<std::function<void()>> m_callbacks;
  void dispatchOnChange();
};

template<typename T>
class Handle : public HandleBase {
public:
  using asset_type = T;
  using HandleBase::HandleBase;
 
  [[nodiscard]]
  auto operator->() noexcept -> T* {
    return static_cast<T*>(this->m_asset);
  }
 
  [[nodiscard]]
  auto operator->() const noexcept -> const T* {
    return static_cast<const T*>(this->m_asset);
  }
 
  [[nodiscard]]
  auto operator*() noexcept -> T& {
    return *static_cast<T*>(this->m_asset);
  }
 
  [[nodiscard]]
  auto operator*() const noexcept -> const T& {
    return *static_cast<const T*>(this->m_asset);
  }
 
  [[nodiscard]]
  auto get() noexcept -> T& {
    return *static_cast<T*>(this->m_asset);
  }
 
  [[nodiscard]]
  auto get() const noexcept -> const T& {
    return *static_cast<const T*>(this->m_asset);
  }
 
  template<typename U>
  auto as() -> Handle<U> {
    return Handle<U>(this->m_asset, this->m_uid, this->m_uri);
  }
};
}