lockfree_list.hpp

#pragma once
 
#include <atomic>
#include <utility>
 
#include "libxr_assert.hpp"
#include "libxr_def.hpp"
 
namespace LibXR
{
 
class LockFreeList
{
 public:
  class BaseNode
  {
   public:
    BaseNode(size_t size);
 
    ~BaseNode();
 
    std::atomic<BaseNode*> next_ =
        nullptr;   
    size_t size_;  
  };
 
  template <typename Data>
  class Node : public BaseNode
  {
   public:
    Node() : BaseNode(sizeof(Data)) {}
 
    explicit Node(const Data& data) : BaseNode(sizeof(Data)), data_(data) {}
 
    template <typename... Args>
    explicit Node(Args&&... args)
        : BaseNode(sizeof(Data)), data_{std::forward<Args>(args)...}
    {
    }
 
    Node& operator=(const Data& data)
    {
      data_ = data;
      return *this;
    }
 
    Data* operator->() noexcept { return &data_; }
    const Data* operator->() const noexcept { return &data_; }
    Data& operator*() noexcept { return data_; }
    operator Data&() noexcept { return data_; }
 
    Data data_;  
  };
 
  LockFreeList() noexcept;
 
  ~LockFreeList();
  void Add(BaseNode& data);
 
  uint32_t Size() noexcept;
 
  template <typename Data, typename Func, SizeLimitMode LimitMode = SizeLimitMode::MORE>
  ErrorCode Foreach(Func func)
  {
    for (auto pos = head_.next_.load(std::memory_order_acquire); pos != &head_;
         pos = pos->next_.load(std::memory_order_relaxed))
    {
      Assert::SizeLimitCheck<LimitMode>(sizeof(Data), pos->size_);
      if (auto res = func(static_cast<Node<Data>*>(pos)->data_); res != ErrorCode::OK)
      {
        return res;
      }
    }
    return ErrorCode::OK;
  }
 
 private:
  BaseNode head_;  
};
 
}  // namespace LibXR