arc.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_MTTHREAD_ARC_HPP
#define MTCORE_MTTHREAD_ARC_HPP
 
#include "mtcore_thread/core.hpp"
#include <atomic>
 
#ifndef MTCORE_NO_STACKTRACE
#include <cpptrace/basic.hpp>
#endif


namespace mtcore::thread {
  namespace impl {
    struct Counter {
      static constexpr u64 zero_flag   = static_cast<u64>(0x1) << static_cast<u64>(63);
      static constexpr u64 helped_flag = static_cast<u64>(0x1) << static_cast<u64>(62);
      std::atomic_uint64_t count       = 1;
 
      [[nodiscard]] bool acquire() { return !(count.fetch_add(1) & zero_flag); }
 
      [[nodiscard]] bool release() {
        if (count.fetch_sub(1) == 1) {
          u64 e = 0;
          if (count.compare_exchange_strong(e, zero_flag)) {
            return true;
          }
          return (e & helped_flag) && count.exchange(zero_flag) & helped_flag;
        }
        return false;
      }
 
      u64 val() {
        auto v = count.load();
        if (v == 0 && count.compare_exchange_strong(v, zero_flag | helped_flag)) {
          return 0;
        }
        return (v & zero_flag) ? 0 : v;
      }
    };

    enum class RefError {
      AllocError      = -1,
      InvalidArgument = -2,
    };
 
    template<typename T>
    struct RefCount {
      T *value  = nullptr;
      Counter c = {};
 
      RefCount() = default;
      RefCount(T *val) : value(val) {}
      RefCount(RefCount &)                      = default;
      RefCount(RefCount &&) noexcept            = default;
      RefCount &operator=(const RefCount &)     = default;
      RefCount &operator=(RefCount &&) noexcept = default;
 
      template<typename... Args>
      [[nodiscard]] static Result<RefCount *, AllocationError> make(Allocator &alloc, Args... args) {
        auto v = alloc.create<T>(args...);
        if (v.is_error()) {
          return v.error();
        }
 
        auto res = alloc.create<RefCount>(v.value());
        return res;
      }
 
      bool acquire() { return c.acquire(); }
 
      bool release(Allocator &alloc) {
        if (c.release()) {
          alloc.destroy(value);
          value = nullptr;
          return true;
        }
        return false;
      }
    };
  }  // namespace impl

  enum class ArcError {
    CannotAcquire = -1,
  };

  template<typename T>
  struct Arc;

  template<typename T>
  struct WeakArc {
    impl::RefCount<impl::RefCount<T>> *rc = nullptr;

    Result<Arc<T>, ArcError> obtain(Allocator &alloc);

    void deinit(Allocator &alloc) {
      if (!rc) {
        return;
      }
      ensure(rc, "Arc is invalid");
      ensure(rc->value, "Arc is invalid");
      if (rc->release(alloc)) {
        alloc.destroy(rc->value);
        rc->value = nullptr;
        alloc.destroy(rc);
      }
      rc = nullptr;
    }

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

    Result<WeakArc, ArcError> copy() {
      ensure(rc, "Arc is invalid");
      if (rc->acquire()) {
        return *this;
      }
      return error(ArcError::CannotAcquire);
    }
  };
 
  template<typename T>
  struct Arc {
    impl::RefCount<impl::RefCount<T>> *rc = nullptr;

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

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

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

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

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

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

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

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

    [[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 outerRcRes = impl::RefCount<impl::RefCount<T>>::make(alloc);
      if (outerRcRes.is_error()) {
        alloc.destroy(val);
        return outerRcRes.error();
      }
      impl::RefCount<impl::RefCount<T>> *outerRc = outerRcRes.value();
      outerRc->value->value                      = valRes.value();
      rc                                         = outerRc;
      return success();
    }

    [[nodiscard]] Result<Arc, ArcError> acquire(Allocator &alloc) {
      ensure(rc, "Arc is invalid");
      if (!rc->acquire()) {
        return error(ArcError::CannotAcquire);
      }
      ensure(rc->value, "Arc is invalid");
      if (!rc->value->acquire()) {
        rc->release(alloc);
        return error(ArcError::CannotAcquire);
      }
      return *this;
    }

    void release(Allocator &alloc) {
      if (!rc) {
        return;
      }
      ensure(rc, "Arc is invalid");
      ensure(rc->value, "Arc is invalid");
      (void) rc->value->release(alloc);
      if (rc->release(alloc)) {
        alloc.destroy(rc->value);
        rc->value = nullptr;
        alloc.destroy(rc);
      }
      rc = nullptr;
    }

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

    Result<WeakArc<T>, ArcError> weak() {
      ensure(rc, "Invalid Arc");
      if (!rc->acquire()) {
        return error(ArcError::CannotAcquire);
      }
      return success(WeakArc<T>{rc});
    }
  };
 
  template<typename T>
  Result<Arc<T>, ArcError> WeakArc<T>::obtain(Allocator &alloc) {
    ensure(rc, "Arc is invalid");
    if (!rc->acquire()) {
      return error(ArcError::CannotAcquire);
    }
 
    if (!rc->value->acquire()) {
      rc->release(alloc);
      return error(ArcError::CannotAcquire);
    }
    return Arc<T>{rc};
  }
}  // namespace mtcore::thread
 
#endif  // MTCORE_MTTHREAD_ARC_HPP