ZAndGate.cpp

Go to the documentation of this file.

#include "ZAndGate.h"
#include <QVariant>
#include <QtQml>
#include "zglobal.h"

namespace Zbl {

ZAndGate::ZAndGate(QObject *parent)
    : QObject(parent), m_value(false)
{

}

void ZAndGate::registerType()
{
    //ZBL_REGISTER_LOGGED_OBJECT

    qmlRegisterType<ZAndGate>("org.zuble.qml", 1, 0, "ZAndGate");
}


bool ZAndGate::getValue()
{
    return m_value;
}

bool ZAndGate::addInputProperty(QObject* targetObject,
                                const QString& propertyName,
                                const QString& signalName)
{
    // TBD: check if input object is in same thread as this object

    // TBD: check if input already exists and if so ignore request, return error

    // TBD: check for errors in following code and abort accordingly

    QString message = ptrStr(targetObject);

    //qDebug("ZAndGate:: target object = %s",message.toUtf8().constData());

    QString sigName;

    if(signalName.isEmpty())
        sigName = QString("%1Changed()").arg(propertyName);
    else
    {
        //sigName = QString("on%1()").arg(signalName);
        sigName = signalName;
    }
    //qDebug("ZAndGate:: signal name = %s", sigName.toUtf8().constData());

    QByteArray normalSig = QMetaObject::normalizedSignature(sigName.toUtf8().constData());
    //qDebug("ZAndGate:: normalized signal name = %s", normalSig.constData());


    // find meta data for object/property changed connection

    const QMetaObject *mo = targetObject->metaObject();

    int sigIndex = mo->indexOfSignal(QMetaObject::normalizedSignature(sigName.toUtf8().constData()));

    //qDebug("ZAndGate:: addInputProperty signal = %d", sigIndex);

    QMetaMethod metaSignal = mo->method(sigIndex);

    int slotIndex = metaObject()->indexOfSlot("onPropChanged()");

    //qDebug("ZAndGate:: addInputProperty slot = %d", slotIndex);

    QMetaMethod metaSlot = metaObject()->method(slotIndex);

    // add prop to map

    m_props.insertMulti(targetObject, proxy(propertyName,targetObject->property(propertyName.toUtf8().constData()).toBool()));

    // connect to property change signal on target object

    connect(targetObject, metaSignal, this, metaSlot);

    evaluate(); // TBD: this is overkill! we need only evaluate the added property!

    return true;
}

bool ZAndGate::removeInputProperty(QObject* targetObject, const QString& propertyName)
{
    qDebug("ZAndGate ==> Oops! removeInputProperty not implemented! Sorry.");
    return false;
}

void ZAndGate::removeAllProperties()
{
    m_props.clear();

    bool previous = m_value;

    m_value = false;

    if(previous != m_value)
        emit outputChanged();
}

void ZAndGate::onPropChanged()
{

    // iterate first to last for sender object
    //   if any prop of sender becomes false and output == true then output = false
    //   else if all props of sender become true and output == false check local copy of all props
    //       of all objects and set output accordingly

    QObject* targetObj = sender();

    QString message = ptrStr(targetObj);
    QString strThis = ptrStr(this);

    //qDebug("ZAndGate:%s ==> sender =%s", cStr(strThis), cStr(message) );

    bool allTrue = true;
    bool valueChanged = false;
    bool foundObject = false;

    propIterator i(m_props);

    while(i.hasNext())
    {
        i.next();

        proxy next = i.value();

        if(i.key() != targetObj)
        {
            if(foundObject)
                break;
            else
                continue;
        }

        foundObject = true;

        bool nextValue = waitGetProperty(targetObj, next.first).toBool();

        if(next.second != nextValue)
        {
            valueChanged = true;

            if(!nextValue)
                allTrue = false;

            i.setValue(proxy(next.first,nextValue));
        }
        else
        {
            if(!next.second)
                allTrue = false;
        }

    }

    if(valueChanged)
    {
        if(!allTrue && m_value)
        {
            m_value = false;

            emit outputChanged();
        }
        else if(allTrue && !m_value)
            evaluate();
    }


}

QVariant ZAndGate::waitGetProperty(QObject* targetObj, const QString& name)
{
    QVariant retValue;

    ZBL_SLOT_BEGIN_TRY

    if(inObjectThread(this))
    {
        retValue = targetObj->property(cStr(name));
    }
    else
    {
        QMetaObject::invokeMethod(targetObj,"property",
                                  Qt::BlockingQueuedConnection,
                                  Q_RETURN_ARG(QVariant, retValue),
                                  Q_ARG(const QString&,name));
    }

    ZBL_SLOT_END_RETURN(retValue,  QVariant(),
    Z_FAC_JS, ZAndGate::waitGetProperty, waitGetProperty failed)
}

void ZAndGate::evaluate()
{
    bool allTrue = true;

    propIterator i(m_props);

    while(i.hasNext())
    {
        i.next();

        proxy next = i.value();

        if(!next.second)
        {
            if(m_value)
            {
                m_value = false;
                emit outputChanged();
            }
            allTrue = false;
            break;
        }
    }

   if(allTrue && !m_value)
    {
        m_value = true;

        emit outputChanged();
    }

}


} // Zbl