list.hpp

#pragma once
 
#include <utility>
 
#include "libxr_assert.hpp"
#include "libxr_def.hpp"
#include "mutex.hpp"
 
namespace LibXR
{
 
class List
{
 public:
  class BaseNode
  {
   public:
    BaseNode(size_t size);
 
    ~BaseNode();
 
    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_;  
  };
 
  List() noexcept;
 
  ~List();
 
  void Add(BaseNode& data);
 
  uint32_t Size() noexcept;
 
  ErrorCode Delete(BaseNode& data) noexcept;
 
  template <typename Data, typename Func, SizeLimitMode LimitMode = SizeLimitMode::MORE>
  ErrorCode Foreach(Func func)
  {
    mutex_.Lock();
    for (auto pos = head_.next_; pos != &head_; pos = pos->next_)
    {
      Assert::SizeLimitCheck<LimitMode>(sizeof(Data), pos->size_);
      if (auto res = func(static_cast<Node<Data>*>(pos)->data_); res != ErrorCode::OK)
      {
        mutex_.Unlock();
        return res;
      }
    }
    mutex_.Unlock();
    return ErrorCode::OK;
  }
 
 private:
  BaseNode head_;       
  LibXR::Mutex mutex_;  
};
 
}  // namespace LibXR