filterStream.h

Go to the documentation of this file.

#ifndef FILTERSTREAM_H
#define FILTERSTREAM_H
 
#include "filter.h"
#include "chain.h"
#include "refCntPtr.h"
 
 
namespace original{
    template<typename TYPE>
    class filterStream
    {
        static const strongPtr<filter<TYPE>> nullFilter;
 
        enum class opts{AND = 1, OR = 0, NOT = 2, LEFT_BRACKET = 3, RIGHT_BRACKET = 4};
 
        mutable chain<strongPtr<filter<TYPE>>> stream; 
        mutable chain<opts> ops; 
        mutable bool flag; 
 
    protected:
        explicit filterStream();
 
        void addBrackets();
 
        void addAndOpt();
 
        void addOrOpt();
 
        void addNotOpt();
 
        void pushEnd(const filter<TYPE>& f);
 
        void pushAll(const filterStream& fs);
 
        void toPostFix() const;
 
    public:
        ~filterStream() = default;
 
        filterStream& operator&&(const filter<TYPE>& f);
 
        filterStream& operator&&(const filterStream& fs);
 
        filterStream& operator||(const filter<TYPE>& f);
 
        filterStream& operator||(const filterStream& fs);
 
        filterStream& operator!();
 
        bool operator()(const TYPE& t) const;
 
        // Friend operator implementations
        template<typename T>
        friend filterStream<T> operator&&(const filter<T>& f1, const filter<T>& f2);
        template<typename T>
        friend filterStream<T> operator&&(const filter<T>& f, const filterStream<T>& ofs);
        template<typename T>
        friend filterStream<T> operator&&(const filterStream<T>& ofs, const filter<T>& f);
        template<typename T>
        friend filterStream<T> operator||(const filter<T>& f1, const filter<T>& f2);
        template<typename T>
        friend filterStream<T> operator||(const filter<T>& f, const filterStream<T>& ofs);
        template<typename T>
        friend filterStream<T> operator||(const filterStream<T>& ofs, const filter<T>& f);
        template<typename T>
        friend filterStream<T> operator!(const filter<T>& f);
        template<typename T>
        friend filterStream<T> operator!(const filterStream<T>& ofs);
        template<typename T>
        friend filterStream<T> group(const filterStream<T>& ofs);
        template<typename T>
        friend filterStream<T> group(const filter<T>& f);
    };
 
    template <typename TYPE>
    const strongPtr<filter<TYPE>> filterStream<TYPE>::nullFilter{};
 
    template<typename T>
    filterStream<T> operator&&(const filter<T>& f1, const filter<T>& f2);
 
    template<typename T>
    filterStream<T> operator&&(const filter<T>& f, const filterStream<T>& ofs);
 
    template<typename T>
    filterStream<T> operator&&(const filterStream<T>& ofs, const filter<T>& f);
 
    template<typename T>
    filterStream<T> operator||(const filter<T>& f1, const filter<T>& f2);
 
    template<typename T>
    filterStream<T> operator||(const filter<T>& f, const filterStream<T>& ofs);
 
    template<typename T>
    filterStream<T> operator||(const filterStream<T>& ofs, const filter<T>& f);
 
    template<typename T>
    filterStream<T> operator!(const filter<T>& f);
 
    template<typename T>
    filterStream<T> operator!(const filterStream<T>& ofs);
 
    template<typename T>
    filterStream<T> group(const filterStream<T>& ofs);
 
    template<typename T>
    filterStream<T> group(const filter<T>& f);
} // namespace original
 
    template <typename TYPE>
    original::filterStream<TYPE>::filterStream() : stream(), ops(), flag(false) {}
 
    template <typename TYPE>
    auto original::filterStream<TYPE>::addBrackets() -> void
    {
        this->stream.pushBegin(nullFilter);
        this->stream.pushEnd(nullFilter);
        this->ops.pushBegin(opts::LEFT_BRACKET);
        this->ops.pushEnd(opts::RIGHT_BRACKET);
    }
 
    template <typename TYPE>
    auto original::filterStream<TYPE>::addAndOpt() -> void
    {
        this->stream.pushEnd(nullFilter);
        this->ops.pushEnd(opts::AND);
    }
 
    template <typename TYPE>
    auto original::filterStream<TYPE>::addOrOpt() -> void
    {
        this->stream.pushEnd(nullFilter);
        this->ops.pushEnd(opts::OR);
    }
 
    template <typename TYPE>
    auto original::filterStream<TYPE>::addNotOpt() -> void
    {
        this->stream.pushBegin(nullFilter);
        this->ops.pushBegin(opts::NOT);
    }
 
    template <typename TYPE>
    auto original::filterStream<TYPE>::pushEnd(const filter<TYPE>& f) -> void
    {
        this->stream.pushEnd(strongPtr<filter<TYPE>>(f.clone()));
    }
 
    template <typename TYPE>
    auto original::filterStream<TYPE>::pushAll(const filterStream& fs) -> void
    {
        for (auto& filter: fs.stream)
        {
            this->stream.pushEnd(filter);
        }
        for (auto& op: fs.ops)
        {
            this->ops.pushEnd(op);
        }
    }
 
    template <typename TYPE>
    auto original::filterStream<TYPE>::toPostFix() const -> void{
        this->flag = true;
 
        chain<strongPtr<filter<TYPE>>> stream_post;
        chain<opts> ops_post;
        chain<opts> ops_tmp;
 
        auto it_stream = this->stream.begins();
        auto it_ops = this->ops.begins();
 
        while (it_stream->isValid()){
            if (it_stream->get() != nullFilter){
                stream_post.pushEnd(it_stream->get());
            } else if (it_ops->isValid()){
                switch (it_ops->get()) {
                    case opts::LEFT_BRACKET:
                        ops_tmp.pushEnd(opts::LEFT_BRACKET);
                        break;
                    case opts::RIGHT_BRACKET:
                        while (!ops_tmp.empty() && ops_tmp[-1] != opts::LEFT_BRACKET){
                            stream_post.pushEnd(nullFilter);
                            ops_post.pushEnd(ops_tmp.popEnd());
                        }
                        ops_tmp.popEnd();
                        break;
                    case opts::NOT:
                        ops_tmp.pushEnd(opts::NOT);
                        break;
                    default:
                        while (!ops_tmp.empty()
                               && ops_tmp[-1] >= it_ops->get()
                               && ops_tmp[-1] != opts::LEFT_BRACKET){
                            stream_post.pushEnd(nullFilter);
                            ops_post.pushEnd(ops_tmp.popEnd());
                        }
                        ops_tmp.pushEnd(it_ops->get());
                        break;
                }
                it_ops->next();
            }
            it_stream->next();
        }
 
        while (!ops_tmp.empty()){
            stream_post.pushEnd(nullFilter);
            ops_post.pushEnd(ops_tmp.popEnd());
        }
        this->stream = stream_post;
        this->ops = ops_post;
        delete it_ops;
        delete it_stream;
    }
 
    template <typename TYPE>
    auto original::filterStream<TYPE>::operator&&(const filter<TYPE>& f) -> filterStream&
    {
        this->addAndOpt();
        this->pushEnd(f);
        return *this;
    }
 
    template <typename TYPE>
    auto original::filterStream<TYPE>::operator&&(const filterStream& fs) -> filterStream&
    {
        this->addAndOpt();
        this->pushAll(fs);
        return *this;
    }
 
    template <typename TYPE>
    auto original::filterStream<TYPE>::operator||(const filter<TYPE>& f) -> filterStream&
    {
        this->addOrOpt();
        this->pushEnd(f);
        return *this;
    }
 
    template <typename TYPE>
    auto original::filterStream<TYPE>::operator||(const filterStream& fs) -> filterStream&
    {
        this->addOrOpt();
        this->pushAll(fs);
        return *this;
    }
 
    template <typename TYPE>
    auto original::filterStream<TYPE>::operator!() -> filterStream&
    {
        this->addBrackets();
        this->addNotOpt();
        return *this;
    }
 
    template <typename TYPE>
    auto original::operator&&(const filter<TYPE> &f1, const filter<TYPE> &f2) -> filterStream<TYPE> {
        filterStream<TYPE> fs;
        fs.pushEnd(f1);
        fs.addAndOpt();
        fs.pushEnd(f2);
        return fs;
    }
 
    template <typename TYPE>
    auto original::operator&&(const filter<TYPE> &f, const filterStream<TYPE> &ofs) -> filterStream<TYPE> {
        filterStream<TYPE> fs;
        fs.pushEnd(f);
        fs.addAndOpt();
        fs.pushAll(ofs);
        return fs;
    }
 
    template<typename TYPE>
    auto original::operator&&(const filterStream<TYPE> &ofs, const filter<TYPE> &f) -> filterStream<TYPE> {
        filterStream<TYPE> fs(ofs);
        return fs && f;
    }
 
    template <typename TYPE>
    auto original::operator||(const filter<TYPE> &f1, const filter<TYPE> &f2) -> filterStream<TYPE> {
        filterStream<TYPE> fs;
        fs.pushEnd(f1);
        fs.addOrOpt();
        fs.pushEnd(f2);
        return fs;
    }
 
    template <typename TYPE>
    auto original::operator||(const filter<TYPE> &f, const filterStream<TYPE> &ofs) -> filterStream<TYPE> {
        filterStream<TYPE> fs;
        fs.pushEnd(f);
        fs.addOrOpt();
        fs.pushAll(ofs);
        return fs;
    }
 
    template<typename TYPE>
    auto original::operator||(const filterStream<TYPE> &ofs, const filter<TYPE> &f) -> filterStream<TYPE> {
        filterStream<TYPE> fs(ofs);
        return fs || f;
    }
 
    template <typename TYPE>
    auto original::operator!(const filter<TYPE> &f) -> filterStream<TYPE> {
        filterStream<TYPE> fs;
        fs.pushEnd(f);
        fs.addNotOpt();
        return fs;
    }
 
    template<typename TYPE>
    auto original::operator!(const filterStream<TYPE> &ofs) -> filterStream<TYPE> {
        filterStream<TYPE> fs(ofs);
        return !fs;
    }
 
    template<typename TYPE>
    auto original::group(const filterStream<TYPE> &ofs) -> filterStream<TYPE> {
        filterStream<TYPE> fs;
        fs.pushAll(ofs);
        fs.addBrackets();
        return fs;
    }
 
    template<typename TYPE>
    auto original::group(const filter<TYPE> &f) -> filterStream<TYPE> {
        filterStream<TYPE> fs;
        fs.pushEnd(f);
        return fs;
    }
 
    template <typename TYPE>
    auto original::filterStream<TYPE>::operator()(const TYPE &t) const -> bool {
        if (!this->flag) this->toPostFix();
 
        chain<bool> value_stack;
        auto it_stream = this->stream.begins();
        auto it_ops = this->ops.begins();
 
        while (it_stream->isValid()){
            if (it_stream->get() != nullFilter){
                value_stack.pushEnd(it_stream->get()->operator()(t));
            } else if (it_ops->isValid()){
                switch (it_ops->get()) {
                    case opts::NOT:
                        value_stack[-1] = !value_stack[-1];
                        break;
                    default:
                        const bool right = value_stack.popEnd();
                        const bool left = value_stack.popEnd();
                        value_stack.pushEnd(it_ops->get() == opts::AND ?
                                                left && right : left || right);
                        break;
                }
                it_ops->next();
            }
            it_stream->next();
        }
        delete it_ops;
        delete it_stream;
        return value_stack[-1];
    }
 
#endif //FILTERSTREAM_H