rc.hpp

Go to the documentation of this file.

#ifndef MTCORE_RC_HPP
#define MTCORE_RC_HPP
 
#include "mtcore/alloc.hpp"
#include "mtcore/colls/result.hpp"
#include "mtcore/core.hpp"
 
namespace mtcore {
  namespace impl {
    struct RcCounter {
      u64 count = 1;
 
      bool acquire() {
        if (count == 0) {
          return false;
        }
        ++count;
        return true;
      }
 
      bool release() {
        ensure(count > 0, "DOUBLE RELEASE DETECTED!");
        --count;
        return count == 0;
      }
 
      u64 val() { return count; }
    };
 
    enum class StrongReleaseAction {
      NONE,
      CLEANUP_RC,
      CLEANUP_VAR_ONLY,
    };
 
    template<typename T>
    struct ThreadLocalRefCount {
      T *value                    = nullptr;
      u64 strongCounter = 1;
      u64 weakCounter = 0;
 
      bool acquireStrong() {
        if (strongCounter == 0 || value == nullptr) {
          return false;
        }
        ++strongCounter;
        return true;
      }
 
      bool acquireWeak() {
        if (strongCounter == 0 && weakCounter == 0) {
          return false;
        }
        ++weakCounter;
        return true;
      }
 
      StrongReleaseAction releaseStrong() {
        ensure(strongCounter > 0, "Double release detected");
        --strongCounter;
        if (strongCounter > 0) {
          return StrongReleaseAction::NONE;
        }
        else if (weakCounter == 0) {
          return StrongReleaseAction::CLEANUP_RC;
        }
        else {
          return StrongReleaseAction::CLEANUP_VAR_ONLY;
        }
      }
 
      bool releaseWeak() {
        ensure(weakCounter > 0, "Double release detected");
        --weakCounter;
        return weakCounter == 0 && strongCounter == 0;
      }
    };
  }  // namespace impl

  enum class RcError {
    CANNOT_ACQUIRE,
  };

  template<typename T>
  struct Rc;

  template<typename T>
  struct WeakRc {
    impl::ThreadLocalRefCount<T> *rc = nullptr;

    Result<Rc<T>, RcError> obtain(Allocator &alloc);

    void deinit(Allocator &alloc) {
      if (!rc) {
        return;
      }
 
      ensure(rc, "Rc is invalid");
      if (rc->releaseWeak()) {
        alloc.destroy(rc);
      }
    }

    [[nodiscard]] bool valid() const { return rc != nullptr; }

    [[nodiscard]] operator bool() const { return valid(); }

    Result<WeakRc, RcError> copy() {
      ensure(rc, "Rc is invalid");
      if (!rc->acquireWeak()) {
        return error(RcError::CANNOT_ACQUIRE);
      }
      return *this;
    }
  };
 
  template<typename T>
  struct Rc {
    impl::ThreadLocalRefCount<T> *rc = nullptr;

    [[nodiscard]] T& operator*() {
      ensure(rc, "Invalid Rc");
      return *rc->value;
    }

    [[nodiscard]] const T &operator*() const {
      ensure(rc, "Invalid Rc");
      return *rc->value;
    }

    [[nodiscard]] T *operator->() {
      ensure(rc, "Invalid Rc");
      return rc->value;
    }

    [[nodiscard]] const T *operator->() const {
      ensure(rc, "Invalid Rc");
      return rc->value;
    }

    [[nodiscard]] bool operator==(const Rc& other) const {
      return rc == other.rc;
    }

    [[nodiscard]] bool operator==(T* other) const {
      if (other == nullptr && rc == nullptr) {
        return true;
      }
      ensure(rc, "Invalid Rc");
      return rc->value == other;
    }

    [[nodiscard]] bool operator==(const T* other) const {
      if (other == nullptr && rc == nullptr) {
        return true;
      }
      ensure(rc, "Invalid Rc");
      return rc->value == other;
    }

    [[nodiscard]] bool valid() const { return rc != nullptr && rc->value != nullptr; }

    [[nodiscard]] operator bool() const { return valid(); }

    template<typename... Args>
    [[nodiscard]] Result<void, AllocationError> init(Allocator& alloc, Args... args) {
      if (rc) {
        release(alloc);
      }
      Result<T*, AllocationError> valRes = alloc.create<T>(args...);
      if (valRes.is_error()) {
        return valRes.error();
      }
      T* val = valRes.value();
 
      auto rcRes = alloc.create<impl::ThreadLocalRefCount<T>>();
      if (rcRes.is_error()) {
        alloc.destroy(val);
        return error(AllocationError::ALLOCATION_FAILED);
      }
      rc = rcRes.value();
      rc->value = val;
      return success();
    }

    [[nodiscard]] Result<Rc, RcError> acquire() {
      ensure(rc, "Rc is invalid");
      if (!rc->acquireStrong()) {
        return error(RcError::CANNOT_ACQUIRE);
      }
      ensure(rc->value, "Rc  is invalid");
      return *this;
    }

    void release(Allocator& alloc) {
      if (!rc) {
        return;
      }
      ensure(rc, "Rc is invalid");
      ensure(rc->value, "Rc is invalid");
      switch (impl::StrongReleaseAction action = rc->releaseStrong()) {
        case impl::StrongReleaseAction::NONE:
          break;
        case impl::StrongReleaseAction::CLEANUP_RC:
          alloc.destroy(rc->value);
          rc->value = nullptr;
          alloc.destroy(rc);
          break;
        case impl::StrongReleaseAction::CLEANUP_VAR_ONLY:
          alloc.destroy(rc->value);
          rc->value = nullptr;
          break;
      }
      rc = nullptr;
    }

    void deinit(Allocator &alloc) {
      release(alloc);
    }

    Result<WeakRc<T>, RcError> weak() {
      ensure(rc, "Invalid Rc");
      if (!rc->acquireWeak()) {
        return error(RcError::CANNOT_ACQUIRE);
      }
      return success(WeakRc<T>{rc});
    }
  };
 
  template<typename T>
  Result<Rc<T>, RcError> WeakRc<T>::obtain(Allocator &alloc) {
    ensure(rc, "arc is invalid");
    if (!rc->acquireStrong()) {
      return error(RcError::CANNOT_ACQUIRE);
    }
    return Rc<T>{rc};
  }
 
}  // namespace mtcore
 
#endif  // MTCORE_RC_HPP