Predicate.h

#pragma once


#include <libutl/FlagsMI.h>


UTL_NS_BEGIN;

// Predicate ///////////////////////////////////////////////////////////////////////////////////////


class Predicate : public Object, protected FlagsMI
{
    UTL_CLASS_DECL_ABC(Predicate, Object);
    UTL_CLASS_DEFID;

public:
    bool
    isOwner() const
    {
        return getFlag(flg_owner);
    }

    void
    setOwner(bool owner)
    {
        setFlag(flg_owner, owner);
    }

    virtual int compare(const Object& rhs) const;

    virtual bool eval(const Object* object) const = 0;

    bool operator()(const Object* object) const
    {
        return eval(object);
    }

private:
    enum flg_t
    {
        flg_owner
    };
};

// IsA /////////////////////////////////////////////////////////////////////////////////////////////


class IsA : public Predicate
{
    UTL_CLASS_DECL(IsA, Predicate);

public:
    IsA(const RunTimeClass* rtc)
    {
        _rtc = rtc;
    }

    virtual bool
    eval(const Object* object) const
    {
        if ((_rtc == nullptr) || (object == nullptr)) return false;
        return object->_isA(_rtc);
    }

private:
    void
    init()
    {
        _rtc = nullptr;
    }
    void
    deInit()
    {
    }
    const RunTimeClass* _rtc;
};

// UnaryPredicate //////////////////////////////////////////////////////////////////////////////////


class UnaryPredicate : public Predicate
{
    UTL_CLASS_DECL_ABC(UnaryPredicate, Predicate);

public:
    UnaryPredicate(const Object& object, bool owner = true);

    UnaryPredicate(const Object* object, bool owner = true);

    void
    clear()
    {
        setObject(nullptr);
    }

    virtual void copy(const Object& rhs);

    virtual void serialize(Stream& stream, uint_t io, uint_t mode = ser_default);

    const Object*
    getObject() const
    {
        return _object;
    }

    void
    setObject(const Object& object)
    {
        if (isOwner())
            setObject(object.clone());
        else
            setObject(&object);
    }

    void
    setObject(const Object* object)
    {
        if (isOwner()) delete _object;
        _object = const_cast<Object*>(object);
    }

protected:
    Object* _object;

private:
    void
    init()
    {
        _object = nullptr;
        setOwner(true);
    }
    void
    deInit()
    {
        clear();
    }
};

// BinaryPredicate /////////////////////////////////////////////////////////////////////////////////


class BinaryPredicate : public Predicate
{
    UTL_CLASS_DECL_ABC(BinaryPredicate, Predicate);

public:
    BinaryPredicate(const Object& lhs, const Object& rhs, bool owner = true);

    BinaryPredicate(const Object* lhs, const Object* rhs, bool owner = true);

    void
    clear()
    {
        setLHS(nullptr);
        setRHS(nullptr);
    }

    virtual void copy(const Object& rhs);

    virtual void serialize(Stream& stream, uint_t io, uint_t mode = ser_default);

    const Object*
    getLHS() const
    {
        return _lhs;
    }

    const Object*
    getRHS() const
    {
        return _rhs;
    }

    void
    setLHS(const Object& lhs)
    {
        if (isOwner())
            setLHS(lhs.clone());
        else
            setLHS(&lhs);
    }

    void
    setLHS(const Object* lhs)
    {
        if (isOwner()) delete _lhs;
        _lhs = const_cast<Object*>(lhs);
    }

    void
    setRHS(const Object& lhs)
    {
        if (isOwner())
            setRHS(lhs.clone());
        else
            setRHS(&lhs);
    }

    void
    setRHS(const Object* rhs)
    {
        if (isOwner()) delete _rhs;
        _rhs = const_cast<Object*>(rhs);
    }

protected:
    Object* _lhs;
    Object* _rhs;

private:
    void
    init()
    {
        _lhs = _rhs = nullptr;
        setOwner(true);
    }
    void
    deInit()
    {
        clear();
    }
};

// ComparisonPredicate /////////////////////////////////////////////////////////////////////////////


class ComparisonPredicate : public UnaryPredicate
{
    UTL_CLASS_DECL_ABC(ComparisonPredicate, UnaryPredicate);

public:
    ComparisonPredicate(const Object& object, bool owner = true, const Ordering* ordering = nullptr)
        : UnaryPredicate(object, owner)
    {
        _ordering = utl::clone(ordering);
    }

    ComparisonPredicate(const Object* object, bool owner = true, const Ordering* ordering = nullptr)
        : UnaryPredicate(object, owner)
    {
        _ordering = utl::clone(ordering);
    }

    int
    cmp(const Object* object) const
    {
        return compareNullable(object, _object, _ordering);
    }

    const Ordering*
    ordering() const
    {
        return _ordering;
    }

    void
    setOrdering(const Ordering& ordering)
    {
        delete _ordering;
        _ordering = ordering.clone();
    }

    void
    setOrdering(Ordering* ordering)
    {
        delete _ordering;
        _ordering = ordering;
    }

private:
    void
    init()
    {
        _ordering = nullptr;
    }
    void
    deInit()
    {
        delete _ordering;
    }

private:
    Ordering* _ordering;
};

// Not /////////////////////////////////////////////////////////////////////////////////////////////


class Not : public UnaryPredicate
{
    UTL_CLASS_DECL(Not, UnaryPredicate);
    UTL_CLASS_DEFID;

public:
    Not(const Predicate* pred, bool owner = true)
        : UnaryPredicate(pred, owner)
    {
    }

    virtual bool
    eval(const Object* object) const
    {
        if ((_object == nullptr) || (object == nullptr)) return false;
        return !utl::cast<Predicate>(_object)->eval(object);
    }
};

// And /////////////////////////////////////////////////////////////////////////////////////////////


class And : public BinaryPredicate
{
    UTL_CLASS_DECL(And, BinaryPredicate);
    UTL_CLASS_DEFID;

public:
    And(const Predicate& lhs, const Predicate& rhs, bool owner = true)
        : BinaryPredicate(lhs, rhs, owner)
    {
    }

    And(const Predicate* lhs, const Predicate* rhs, bool owner = true)
        : BinaryPredicate(lhs, rhs, owner)
    {
    }

    virtual bool
    eval(const Object* object) const
    {
        return lhs()->eval(object) && rhs()->eval(object);
    }

    const Predicate*
    lhs() const
    {
        return utl::cast<Predicate>(_lhs);
    }

    const Predicate*
    rhs() const
    {
        return utl::cast<Predicate>(_rhs);
    }
};

// Or //////////////////////////////////////////////////////////////////////////////////////////////


class Or : public BinaryPredicate
{
    UTL_CLASS_DECL(Or, BinaryPredicate);
    UTL_CLASS_DEFID;

public:
    Or(const Predicate& lhs, const Predicate& rhs, bool owner = true)
        : BinaryPredicate(lhs, rhs, owner)
    {
    }

    Or(const Predicate* lhs, const Predicate* rhs, bool owner = true)
        : BinaryPredicate(lhs, rhs, owner)
    {
    }

    virtual bool
    eval(const Object* object) const
    {
        return lhs()->eval(object) || rhs()->eval(object);
    }

    const Predicate*
    lhs() const
    {
        return utl::cast<Predicate>(_lhs);
    }

    const Predicate*
    rhs() const
    {
        return utl::cast<Predicate>(_rhs);
    }
};

// EqualTo /////////////////////////////////////////////////////////////////////////////////////////


class EqualTo : public ComparisonPredicate
{
    UTL_CLASS_DECL(EqualTo, ComparisonPredicate);
    UTL_CLASS_DEFID;

public:
    EqualTo(const Object& object, bool owner = true, const Ordering* ordering = nullptr)
        : ComparisonPredicate(object, owner, ordering)
    {
    }

    EqualTo(const Object* object, bool owner = true, const Ordering* ordering = nullptr)
        : ComparisonPredicate(object, owner, ordering)
    {
    }

    virtual bool
    eval(const Object* object) const
    {
        return (cmp(object) == 0);
    }
};

// LessThan ////////////////////////////////////////////////////////////////////////////////////////


class LessThan : public ComparisonPredicate
{
    UTL_CLASS_DECL(LessThan, ComparisonPredicate);
    UTL_CLASS_DEFID;

public:
    LessThan(const Object& object, bool owner = true, const Ordering* ordering = nullptr)
        : ComparisonPredicate(object, owner, ordering)
    {
    }

    LessThan(const Object* object, bool owner = true, const Ordering* ordering = nullptr)
        : ComparisonPredicate(object, owner, ordering)
    {
    }

    virtual bool
    eval(const Object* object) const
    {
        return (cmp(object) < 0);
    }
};

// LessThanOrEqualTo ///////////////////////////////////////////////////////////////////////////////


class LessThanOrEqualTo : public ComparisonPredicate
{
    UTL_CLASS_DECL(LessThanOrEqualTo, ComparisonPredicate);
    UTL_CLASS_DEFID;

public:
    LessThanOrEqualTo(const Object& object, bool owner = true, const Ordering* ordering = nullptr)
        : ComparisonPredicate(object, owner, ordering)
    {
    }

    LessThanOrEqualTo(const Object* object, bool owner = true, const Ordering* ordering = nullptr)
        : ComparisonPredicate(object, owner, ordering)
    {
    }

    virtual bool
    eval(const Object* object) const
    {
        return (cmp(object) <= 0);
    }
};

// GreaterThan /////////////////////////////////////////////////////////////////////////////////////


class GreaterThan : public ComparisonPredicate
{
    UTL_CLASS_DECL(GreaterThan, ComparisonPredicate);
    UTL_CLASS_DEFID;

public:
    GreaterThan(const Object& object, bool owner = true, const Ordering* ordering = nullptr)
        : ComparisonPredicate(object, owner, ordering)
    {
    }

    GreaterThan(const Object* object, bool owner = true, const Ordering* ordering = nullptr)
        : ComparisonPredicate(object, owner, ordering)
    {
    }

    virtual bool
    eval(const Object* object) const
    {
        return (cmp(object) > 0);
    }
};

// GreaterThanOrEqualTo ////////////////////////////////////////////////////////////////////////////


class GreaterThanOrEqualTo : public ComparisonPredicate
{
    UTL_CLASS_DECL(GreaterThanOrEqualTo, ComparisonPredicate);
    UTL_CLASS_DEFID;

public:
    GreaterThanOrEqualTo(const Object& object,
                         bool owner = true,
                         const Ordering* ordering = nullptr)
        : ComparisonPredicate(object, owner, ordering)
    {
    }

    GreaterThanOrEqualTo(const Object* object,
                         bool owner = true,
                         const Ordering* ordering = nullptr)
        : ComparisonPredicate(object, owner, ordering)
    {
    }

    virtual bool
    eval(const Object* object) const
    {
        return (cmp(object) >= 0);
    }
};


UTL_NS_END;


inline utl::Not operator!(const utl::Predicate& pred)
{
    return utl::Not(pred, false);
}


inline utl::And operator&&(const utl::Predicate& lhs, const utl::Predicate& rhs)
{
    return utl::And(lhs, rhs, false);
}


inline utl::Or operator||(const utl::Predicate& lhs, const utl::Predicate& rhs)
{
    return utl::Or(lhs, rhs, false);
}