lazyevaluation.hpp

/* Copyright (c) 2014-2015, The Nuria Project
 * The NuriaProject Framework is free software: you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public License as
 * published by the Free Software Foundation, either version 3 of the License,
 * or (at your option) any later version.
 * 
 * The NuriaProject Framework is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Lesser General Public License for more details.
 * 
 * You should have received a copy of the GNU Lesser General Public License
 * along with The NuriaProject Framework.
 * If not, see <http://www.gnu.org/licenses/>.
 */

#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