object_table.h

Go to the documentation of this file.

 
#pragma once
 
#include <memory>
#include <optional>
#include <span>
#include <string_view>
#include <utility>
#include <vector>
 
#include <rex/kernel/object/kernel_object.h>
#include <rex/kernel/object/object_block.h>
#include <rex/kernel/object/object_pin.h>
#include <rex/kernel/object/xam_object.h>
#include <rex/kernel/types/status.h>
#include <rex/logging/log_category.h>
#include <rex/module.h>
#include <rex/platform.h>
#include <rex/result.h>
#include <rex/types.h>
 
namespace rex::kernel {
 
struct AddOptions {
  std::string_view name; 
  ObjectBlock block;
};

REX_DECLARE_INTERFACE(IObjectTable, 2)
  virtual ~IObjectTable() = default;

  [[nodiscard]] virtual Result<X_HANDLE> Add(std::unique_ptr<KernelObject> object,
                                             const AddOptions& options) = 0;

  [[nodiscard]] virtual Result<X_HANDLE> AddWithBlock(std::unique_ptr<KernelObject> object,
                                                      u32 attributes_ptr, u32 block_size) = 0;

  [[nodiscard]] virtual ObjectBlock AllocateObjectBlock(u32 size, ObjectType type,
                                                        ObjectBlockHeap heap) = 0;

  [[nodiscard]] virtual Result<X_HANDLE> AddEvent(bool manual_reset, bool initial_state) = 0;

  [[nodiscard]] virtual Result<X_HANDLE> AddXAMObject(std::unique_ptr<IXAMObject> body,
                                                      const AddOptions& options) = 0;

  [[nodiscard]] virtual Result<X_HANDLE> AddFile(std::unique_ptr<filesystem::IFile> file,
                                                 bool synchronous) = 0;

  [[nodiscard]] virtual Result<X_HANDLE> Duplicate(X_HANDLE handle) = 0;

  [[nodiscard]] virtual Result<X_HANDLE> Open(const ObjectPin& object) = 0;

  [[nodiscard]] virtual Result<void> Close(X_HANDLE handle) = 0;

  [[nodiscard]] virtual Result<void> Reference(const ObjectPin& object) = 0;

  [[nodiscard]] virtual Result<void> Dereference(const ObjectPin& object) = 0;

  [[nodiscard]] virtual ObjectPin GetByAddress(u32 address) = 0;

  [[nodiscard]] virtual ObjectPin Get(X_HANDLE handle) = 0;

  [[nodiscard]] virtual std::vector<ObjectPin> GetAll() = 0;

  [[nodiscard]] std::optional<std::vector<ObjectPin>> GetEach(std::span<const X_HANDLE> handles) {
    std::vector<ObjectPin> pins;
    pins.reserve(handles.size());
    for (const X_HANDLE handle : handles) {
      ObjectPin pin = Get(handle);
      if (!pin) {
        return std::nullopt;
      }
      pins.push_back(std::move(pin));
    }
    return pins;
  }

  [[nodiscard]] virtual Result<void> AddName(std::string_view name, X_HANDLE handle) = 0;

  [[nodiscard]] virtual Result<X_HANDLE> OpenByName(std::string_view name) = 0;

  [[nodiscard]] virtual ObjectPin ResolveObject(u32 address, i32 as_type) = 0;

  virtual void ForgetAddress(u32 address) = 0;

  template <typename T, typename... Args>
  [[nodiscard]] Result<X_HANDLE> Emplace(const AddOptions& options, Args&&... args) {
    if constexpr (XAMObjectClass<T>) {
      return AddXAMObject(std::make_unique<T>(std::forward<Args>(args)...), options);
    } else {
      return Add(MakeObject<T>(std::forward<Args>(args)...), options);
    }
  }

  template <typename T, typename... Args>
  [[nodiscard]] Result<X_HANDLE> CreateObject(u32 attributes_ptr, u32 block_size, Args&&... args) {
    return AddWithBlock(MakeObject<T>(std::forward<Args>(args)...), attributes_ptr, block_size);
  }

  template <typename T>
  [[nodiscard]] Pinned<T> Get(X_HANDLE handle) {
    return Pinned<T>(Get(handle));
  }

  template <typename T>
  [[nodiscard]] std::vector<Pinned<T>> All() {
    std::vector<Pinned<T>> results;
    for (ObjectPin& slot : GetAll()) {
      Pinned<T> pin(std::move(slot));
      if (pin) {
        results.push_back(std::move(pin));
      }
    }
    return results;
  }

  template <typename T>
  [[nodiscard]] Pinned<T> Resolve(u32 address, i32 as_type = -1) {
    return Pinned<T>(ResolveObject(address, as_type));
  }
};

inline void CloseOwned(IObjectTable& table, X_HANDLE handle) noexcept {
  log::NoThrow(log::system, [&] {
    if (auto closed = table.Close(handle); !closed) {
      REXSYS_WARN("Handle {:08X} did not close, {}", handle, closed.error().message);
    }
  });
}
 
}  // namespace rex::kernel