rc.hpp

Go to the documentation of this file.

/*
 
Copyright 2025 Matthew Tolman
 
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
 
   http://www.apache.org/licenses/LICENSE-2.0
 
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
 
*/
 
#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