IFilter.h

Go to the documentation of this file.

#pragma once

#include <list>
#include <vector>
#include "ICharacter.h"
#include "AI.h"
#include "common/MemoryAllocator.h"
#include "common/Thread.h"

namespace ai {

#define FILTER_CLASS(FilterName) \
    explicit FilterName(const std::string& parameters = "") : \
        ::ai::IFilter(#FilterName, parameters) { \
    } \
public: \
    virtual ~FilterName() { \
    }

#define FILTER_FACTORY(FilterName) \
public: \
    class Factory: public ::ai::IFilterFactory { \
    public: \
        ::ai::FilterPtr create (const ::ai::FilterFactoryContext *ctx) const override { \
            return std::make_shared<FilterName>(ctx->parameters); \
        } \
    }; \
    static const Factory& getFactory() { \
        static Factory FACTORY; \
        return FACTORY; \
    }

#define FILTER_ACTION_CLASS(FilterName) \
    FilterName(const std::string& parameters, const ::ai::Filters& filters) : \
        ::ai::IFilter(#FilterName, parameters), _filters(filters) { \
        ai_assert(_filters.size() > 1, #FilterName " must contain at least two sub filters"); \
    } \
protected: \
    const ::ai::Filters _filters; \
public: \
    virtual ~FilterName() { \
    }

#define FILTER_ACTION_FACTORY(FilterName) \
public: \
    class Factory: public ::ai::IFilterFactory { \
    public: \
        ::ai::FilterPtr create (const ::ai::FilterFactoryContext *ctx) const override { \
            return std::make_shared<FilterName>(ctx->parameters, ctx->filters); \
        } \
    }; \
    static const Factory& getFactory() { \
        static Factory FACTORY; \
        return FACTORY; \
    }

#define FILTER_FACTORY_SINGLETON \
public: \
    class Factory: public ::ai::IFilterFactory { \
        ::ai::FilterPtr create (const ::ai::FilterFactoryContext */*ctx*/) const override { \
            return get(); \
        } \
    }; \
    static const Factory& getFactory() { \
        static Factory FACTORY; \
        return FACTORY; \
    }

#define FILTER_CLASS_SINGLETON(FilterName) \
private: \
FILTER_CLASS(FilterName) \
public: \
    static ::ai::FilterPtr& get() { \
        AI_THREAD_LOCAL FilterName* c = nullptr; \
        if (c == nullptr) { c = new FilterName; } \
        AI_THREAD_LOCAL ::ai::FilterPtr _instance(c); \
        return _instance; \
    } \
    FILTER_FACTORY_SINGLETON

class IFilter : public MemObject {
protected:
    const std::string _name;
    const std::string _parameters;

    inline FilteredEntities& getFilteredEntities(const AIPtr& ai) {
        return ai->_filteredEntities;
    }
public:
    IFilter (const std::string& name, const std::string& parameters) :
            _name(name), _parameters(parameters) {
    }

    virtual ~IFilter () {
    }

    inline const std::string& getName() const {
        return _name;
    }

    inline const std::string& getParameters() const {
        return _parameters;
    }

    virtual void filter (const AIPtr& entity) = 0;
};

}