FunctionContainer.hpp

Go to the documentation of this file.

#pragma once
 
#include "BaseFunction.hpp"
 
#include <list>
#include <memory>
#include <unordered_map>
#include <vector>
 
namespace FunctionUtils {
template <typename TReturn, typename... TArgs> class FunctionContainer {
  public:
    using FunctionType = BaseFunction<TReturn, TArgs...>;

    template <typename T> struct is_derived_from_function_type : std::is_base_of<FunctionType, std::decay_t<T>> {};
 
  public:
    FunctionContainer() = default;

    ~FunctionContainer() = default;

    FunctionContainer(const FunctionContainer &) = delete;

    FunctionContainer &operator=(const FunctionContainer &) = delete;

    FunctionContainer(FunctionContainer &&) noexcept = default;

    FunctionContainer &operator=(FunctionContainer &&) noexcept = default;

    template <typename TCallable> FunctionID AddFunction(TCallable callable);

    FunctionID AddFunction(std::unique_ptr<FunctionType> &&function);

    template <typename... TFunctions> decltype(auto) AddFunctions(TFunctions... functions)
    {
        std::array<FunctionID, sizeof...(TFunctions)> temp{AddFunction(functions)...};
        return std::tuple_cat(temp);
    }

    inline const std::list<std::unique_ptr<FunctionType>> &GetFunctions() { return _orderedFunctions; }

    inline bool IsEmpty() const { return _orderedFunctions.empty(); }

    inline std::size_t Size() const { return _orderedFunctions.size(); }

    std::unique_ptr<FunctionType> DeleteFunction(FunctionID id);
 
    inline bool Contains(FunctionID id) const { return _idToIterator.contains(id); }
 
  private:
    std::list<std::unique_ptr<FunctionType>> _orderedFunctions; 
    std::unordered_map<FunctionID, typename std::list<std::unique_ptr<FunctionType>>::iterator>
        _idToIterator; 
};
} // namespace FunctionUtils
 
#include "FunctionContainer.inl"