lazyevaluation.hpp

/* Copyright (c) 2014, The Nuria Project
 * This software is provided 'as-is', without any express or implied
 * warranty. In no event will the authors be held liable for any damages
 * arising from the use of this software.
 * Permission is granted to anyone to use this software for any purpose,
 * including commercial applications, and to alter it and redistribute it
 * freely, subject to the following restrictions:
 *    1. The origin of this software must not be misrepresented; you must not
 *       claim that you wrote the original software. If you use this software
 *       in a product, an acknowledgment in the product documentation would be
 *       appreciated but is not required.
 *    2. Altered source versions must be plainly marked as such, and must not be
 *       misrepresented as being the original software.
 *    3. This notice may not be removed or altered from any source
 *       distribution.
 */

#ifndef NURIA_LAZYEVALUATION_HPP
#define NURIA_LAZYEVALUATION_HPP

#include "essentials.hpp"
#include "callback.hpp"
#include "variant.hpp"
#include <QSharedData>
#include <QMetaType>
#include <QVariant>
#include <QDebug>

namespace Nuria {

class AbstractConditionEvaluator;
class LazyConditionPrivate;
class Field;

class NURIA_CORE_EXPORT LazyCondition {
public:
    
    enum Type {
        Empty = 0, 
        Single, 
        Equal, 
        NonEqual, 
        Greater, 
        GreaterEqual, 
        Less, 
        LessEqual, 
        LogicAnd, 
        LogicOr 
    };
    
    LazyCondition ();
    
    ~LazyCondition ();
    
    LazyCondition (const Field &field);
    
    LazyCondition (const QVariant &single);
    
    LazyCondition (const LazyCondition &other);
    
    LazyCondition (const QVariant &left, Type type, const QVariant &right);
    
    LazyCondition &operator= (const LazyCondition &other);
    
    bool isValid () const;
    
    Type type () const;
    
    const QVariant &left () const;
    
    const QVariant &right () const;
    
    operator QVariant () const;
    
    LazyCondition operator&& (const LazyCondition &other);
    
    LazyCondition operator|| (const LazyCondition &other);
    
    template< typename ... Args >
    inline bool operator() (const Args & ... args)
    { return evaluate (Variant::buildList (args ...)); }
    
    bool evaluate (const QVariantList &arguments) const;
    
    void compile (AbstractConditionEvaluator *evaluator = nullptr);
    
private:
    QSharedDataPointer< LazyConditionPrivate > d;
};

class NURIA_CORE_EXPORT Field {
public:
    
    enum Type {
        Empty = 0,
        
        Value,
        
        Argument,
        
        TestCall,
        
        Custom = 50
    };
    
    Field ();
    
    Field (int type, const QVariant &data);
    
    Field (const Field &other);
    
    // 
    LazyCondition operator== (const Field &other);
    LazyCondition operator!= (const Field &other);
    LazyCondition operator< (const Field &other);
    LazyCondition operator<= (const Field &other);
    LazyCondition operator> (const Field &other);
    LazyCondition operator>= (const Field &other);
    
    // 
    template< typename T >
    LazyCondition operator== (const T &other)
    { return LazyCondition (toVariant (), LazyCondition::Equal, QVariant::fromValue (other)); }
    
    template< typename T >
    LazyCondition operator!= (const T &other)
    { return LazyCondition (toVariant (), LazyCondition::NonEqual, QVariant::fromValue (other)); }
    
    template< typename T >
    LazyCondition operator< (const T &other)
    { return LazyCondition (toVariant (), LazyCondition::Less, QVariant::fromValue (other)); }
    
    template< typename T >
    LazyCondition operator<= (const T &other)
    { return LazyCondition (toVariant (), LazyCondition::LessEqual, QVariant::fromValue (other)); }
    
    template< typename T >
    LazyCondition operator> (const T &other)
    { return LazyCondition (toVariant (), LazyCondition::Greater, QVariant::fromValue (other)); }
    
    template< typename T >
    LazyCondition operator>= (const T &other)
    { return LazyCondition (toVariant (), LazyCondition::GreaterEqual, QVariant::fromValue (other)); }
    
    const QVariant &value () const;
    
    Type type () const;
    
    int customType () const;
    
    QVariant toVariant () const;
    
private:
    Type m_type;
    QVariant m_value;
};

class NURIA_CORE_EXPORT TestCall {
public:
    
    TestCall ();
    
    TestCall (const QString &name, const QVariantList &args);
    
    TestCall (const Nuria::Callback &callback, const QVariantList &args);
    
    bool isNative () const;
    
    QString name () const;
    
    Nuria::Callback callback () const;
    
    const QVariantList &arguments () const;
    
private:
    QVariant m_method;
    QVariantList m_args;
};

template< typename T > inline Field val (const T &value)
{ return Field (Field::Value, QVariant::fromValue (value)); }

NURIA_CORE_EXPORT Field arg (int index);

template< typename ... Args >
Field test (const QString &method, const Args &... args) {
    TestCall call (method, Variant::buildList (args ...));
    return Field (Field::TestCall, QVariant::fromValue (call));
}

template< typename ... Args >
Field test (const Nuria::Callback &method, const Args &... args) {
    TestCall call (method, Variant::buildList (args ...));
    return Field (Field::TestCall, QVariant::fromValue (call));
}

}

NURIA_CORE_EXPORT QDebug operator<< (QDebug dbg, const Nuria::LazyCondition &condition);
NURIA_CORE_EXPORT QDebug operator<< (QDebug dbg, const Nuria::TestCall &call);
NURIA_CORE_EXPORT QDebug operator<< (QDebug dbg, const Nuria::Field &field);
// 
Q_DECLARE_METATYPE(Nuria::LazyCondition)
Q_DECLARE_METATYPE(Nuria::TestCall)
Q_DECLARE_METATYPE(Nuria::Field)

#endif // NURIA_LAZYEVALUATION_HPP