filter.h

Go to the documentation of this file.

 
#pragma once
 
#include <config.h>
 
#include <cstdlib>
 
#include <string>
#include <vector>
#include <memory>
 
#include "enumeratedarray.h"
#include "musictypes.h"
 
namespace Query {
    class Constraints;
    class Details;
    class List;
};
 
class Filter {
    friend class Constraints;
    friend class Query::Details;
    friend class Query::List;
public:
    enum class Field {
        Invalid = 0,
        Id,
        Artist,
        Album,
        Type,
        Genre,
        Playlist,
        Title,          
        Search,
        Name,
        Year,
        Duration,
        Lastplay,
        Track,          
        Rating,
        Played,
        Heard,
        Rated,
        UserRating,
        False,
        Compilation,
        Count
    };
    static const unsigned FieldCount = static_cast <unsigned> (Field::Count);
 
    enum class Action {
        Noop,
        And,
        Or,
        LessThan,
        LessEqual,
        Equal,
        NotEqual,
        GreaterThan,
        GreaterEqual,
        Match
    };
 
    using DuplicationFlags = EnumeratedArray<Field, bool>;
    using FilterRating = float;
 
protected:
    class ParseError : public std::exception {
    public:
        std::string reason;
        const char *point;
        ParseError (const std::string &_reason, const char *where)
        : reason (_reason), point (where) {};
    };
    class InvalidValue : public std::exception {
    public:
        std::string field;
        std::string value;
        InvalidValue (const std::string &_field, const std::string &_value)
        : field (_field), value (_value) {};
    };
    class DisallowedOperator : public std::exception {
    public:
        std::string field;
        std::string op;
        DisallowedOperator (const std::string &_field, const std::string &_operator)
        : field (_field), op (_operator) {};
    };
 
    class Operation;
    using Op = std::unique_ptr<Operation>;
    inline const char *skipWhitespace (const char **const command) {
        while (isspace (**command)) {
            (*command)++;
        }
        return *command;
    }
 
    std::string gatherString (const char **const command, const char *error_reason);
    Op parseParenthesis (const char **const command);
    Op parseComparison (const char **const command);
    Op parseSearch (const char **const command);
    Op parseNegation (const char **const command);
    Op parseOr (const char **const command);
    Op parseAnd (const char **const command);
 
    class Operation {
        friend class Query::List;
        friend Op Filter::parseNegation (const char **const command);
    private:
        Field field = Field::Invalid; 
        Action action = Action::Noop; 
        bool invert = false; 
        union value_t {
            long numeric; 
            MusicThingie::Type type; 
            struct rating_t {
                float value; 
                const User *user; 
            } rating;
            struct string_t {
                char *value; 
                size_t match_length; 
            } string;
            struct subnodes_t {
                Operation *l_eval; 
                Operation *r_eval; 
            } nodes;
        } value;
        void clear ();
    public:
        inline Operation () {
            memset (&value, '\0', sizeof (value));
        };
        inline ~Operation () {
            clear ();
        };
 
        std::string toString ();
        inline Operation (const Action _action, const Field _field)
        : Operation () {
            action = _action;
            field = _field;
        };
        Operation (const Action action, std::unique_ptr<Filter::Operation> &&left, std::unique_ptr<Filter::Operation> &&right);
        Operation (const Action action, const Field field, const std::string &_value, const bool wildcard = false);
        Operation (const Action action, const Field field, const long value);
        Operation (const Action action, const Field field, const FilterRating value, const User *user);
        Operation (const Action action, const Field field, const MusicThingie::Type type);
 
        // Copy and move operations.
        Operation (const Operation &) = delete;
        Operation &operator =(const Operation &) = delete;
        Operation (Operation &&from);
        Operation &operator =(Operation &&from);
 
 
        // Operation execution methods
        template<typename DiffType>
        bool applyOperation (DiffType diff) const;
        
        inline bool numericCheck (long compare_to) const {
            return compare_to == 0 ? false : applyOperation (compare_to - value.numeric);
        };
        bool stringCheck (const std::string &compare_to) const;
 
        bool genreCheck (const std::string &list) const;
 
        bool evaluate (const PianodPlaylist *playlist) const;
        bool evaluate (const PianodArtist *artist) const;
        bool evaluate (const PianodAlbum *album) const;
        bool evaluate (const PianodSong *track) const;
 
        // Static functions
        static bool isNumericOperator (Action action);
        static bool isStringOperator (Action action);
        static bool isStringField (Field field);
        static MusicThingie::Type getTypeFromField (const Filter::Field field);
    };
 
    std::shared_ptr<Operation> parsetree;
    bool persistable = true; 
 
public:
    const static Filter All; 
    const static Filter None; 
 
    Filter (void) {};
    Filter (const Filter &) = default;
    Filter (Filter &&from_filter) = default;
    Filter (const std::string &expression);
    Filter (const MusicThingie *thing,
            const MusicThingie::Type type = MusicThingie::Type (0),
            const DuplicationFlags &manner = DuplicationFlags (true));
 
    Filter &operator=(const std::string &expression);
    Filter &operator=(const Filter &filter) = default;
    Filter &operator=(Filter &&from_filter) = default;
 
 
    virtual ~Filter ();
 
    template<typename MusicThing> inline bool matches (const MusicThing *thing) const {
        if (!parsetree) return true;
        return (parsetree->evaluate (thing));
    };
 
    inline bool canPersist (void) const  {
        return persistable;
    }
    std::string toString () const;
};
 
template<> bool Filter::matches<MusicThingie> (const MusicThingie *thing) const;
 
 
 
class PermutedFilter: public Filter {
    friend class Query::List;
private:
    std::vector<std::string> phrases;
    const Field target_field;
public:
    PermutedFilter (const std::string &phrase, Field search_target = Field::Search);
    PermutedFilter (const std::vector<std::string> &phrases, Field search_target = Field::Search);
};
 
 
 
class ListFilter: public Filter {
public:
    ListFilter (const std::vector<std::string> &items, Field search_target = Field::Search);
};