TListener.h

Go to the documentation of this file.

#pragma once
#include <functional>
#include <memory>
#include <misc/gen/pointer.h>
 
namespace sf
{
 
class ListenerList
{
  public:
    struct base_type
    {
        virtual ~base_type() = default;
 
        virtual bool validListener() = 0;
    };
 
    ~ListenerList()
    {
      flushListeners();
    }
 
    size_t flushListeners()
    {
      size_t rv = list.size();
      for (auto entry: list)
      {
        delete_null(entry);
      }
      list.clear();
      return rv;
    }
 
    size_t removeListener(base_type* entry)
    {
      size_t rv = 0;
      for (list_type::size_type i = 0; i < list.size(); i++)
      {
        if (list.at(i) == entry)
        {
          list.erase(list.begin() + i, list.begin() + i + 1);// NOLINT(cppcoreguidelines-narrowing-conversions)
          rv++;
        }
      }
      return rv;
    }
 
    size_t cleanupListeners()
    {
      size_t rv = 0;
      // Iterate through the list of weak pointers.
      for (auto it = list.begin(); it != list.end();)
      {
        auto entry = *it;
        if (!entry->validListener())
        {
          // Remove the expired entry.
          list.erase(it);
          // Delete the entry.
          delete entry;
          // Increment the return value/
          rv++;
          // Do not move the iterator since erase has the same effect.
          continue;
        }
        ++it;
      }
      return rv;
    }
 
  private:
    void appendListener(base_type* entry)
    {
      // Do some cleanup if possible.
      cleanupListeners();
      // Add the new entry.
      list.insert(list.end(), entry);
    }
 
    typedef std::vector<base_type*> list_type;
    list_type list;
 
    template<typename... Args>
    friend class TListener;
};
 
template<typename... Args>
class TListener : private ListenerList::base_type
{
  public:
    typedef std::function<void(Args...)> func_type;
    typedef TListener<Args...> listener_type;
 
    explicit TListener(ListenerList* list, const func_type& lambda)
      : owner(list)
    {
      owner->appendListener(this);
      ptr.reset(new func_type(lambda));
    }
 
    TListener(const TListener&) = delete;
 
  public:
    ~TListener() override
    {
      ptr.reset();
      owner->removeListener(this);
    }
 
    class emitter_type
    {
      public:
        emitter_type() = default;
        ~emitter_type()// NOLINT(modernize-use-equals-default)
        {
          // Iterate through the list of weak pointers.
          for (auto& i: list)
          {
            if (!i.expired())
            {
              // Assign an empty.
              *i.lock().get() = func_type();
            }
          }
        }
 
        TListener* linkListener(ListenerList* listener_list, const func_type& function)
        {
          auto rv = new TListener(listener_list, function);
          list.insert(list.end(), rv->ptr);
          return rv;
        }
 
        void callListeners(Args... args)
        {
          // Iterate through the list of weak pointers.
          for (auto it = list.begin(); it != list.end();)
          {
            if (it->expired())
            {
              // Erase the expired entry.
              list.erase(it);
              // Do not move the iterator since erase has the same effect.
              continue;
            }
            // Execute the function.
            (*it->lock().get())(args...);
            // Move to the next instance in the list.
            ++it;
          }
        }
 
        size_t cleanup()
        {
          size_t rv = 0;
          // Iterate through the list of weak pointers.
          for (auto it = list.begin(); it != list.end();)
          {
            if (it->expired())
            {
              // Erase the expired entry.
              list.erase(it);
              // Increment the return value/
              rv++;
            }
            else
            {
              // Move to the next instance in the list.
              ++it;
            }
          }
          return rv;
        }
 
        void flush()
        {
          list.clear();
        }
 
      private:
        std::vector<std::weak_ptr<func_type>> list;
    };
 
  private:
    bool validListener() override
    {
      return !!*ptr.get();
    }
 
    ListenerList* owner;
    std::shared_ptr<func_type> ptr{};
};
 
}// namespace sf