/****************************************************************************
** Generated from 'Example.IVI.Remote.qface'
**
** Created by: The QFace generator (QtAS 5.12.8)
**
** WARNING! All changes made in this file will be lost!
*****************************************************************************/

#include "processingservice.h"
#include "processingservice_p.h"
#include "processingservicebackendinterface.h"

#include <QQmlEngine>
#include <QIviServiceObject>
#include <QIviProxyServiceObject>

/*!
    \class ProcessingService
    \inmodule Example.IVI.Remote

    The ProcessingService provides a QML interface to a service doing all sorts of heavy processing
*/

/*!
    \qmltype UiProcessingService
    \instantiates ProcessingService
    \inherits AbstractFeature

    The ProcessingService provides a QML interface to a service doing all sorts of heavy processing
*/

/*! \internal */
ProcessingServicePrivate::ProcessingServicePrivate(const QString &interface, ProcessingService *parent)
    : QIviAbstractFeaturePrivate(interface, parent)
    , q_ptr(parent)
    , m_lastMessage(QString())
{
    m_supportsPropertyOverriding = true;
}

/*! \internal */
ProcessingServicePrivate *ProcessingServicePrivate::get(ProcessingService *v)
{
    return reinterpret_cast<ProcessingServicePrivate *>(v->d_ptr.data());
}

/*! \internal */
const ProcessingServicePrivate *ProcessingServicePrivate::get(const ProcessingService *v)
{
    return reinterpret_cast<const ProcessingServicePrivate *>(v->d_ptr.data());
}

/*! \internal */
ProcessingService *ProcessingServicePrivate::getParent()
{
    return q_ptr;
}

/*! \internal */
void ProcessingServicePrivate::clearToDefaults()
{
    m_lastMessage = QString();
}

/*! \internal */
void ProcessingServicePrivate::onLastMessageChanged(const QString &lastMessage)
{
    if (m_lastMessage != lastMessage) {
        auto q = getParent();
        m_lastMessage = lastMessage;
        emit q->lastMessageChanged(lastMessage);
    }
}

bool ProcessingServicePrivate::notify(const QByteArray &propertyName, const QVariant &value)
{
    auto q = getParent();
    if (propertyName == QByteArray("lastMessage")) {
        emit q->lastMessageChanged(value.value<QString>());
        return true;
    }
    return QIviAbstractFeaturePrivate::notify(propertyName, value);
}

/*!
    Default constructs an instance of ProcessingService.
*/
ProcessingService::ProcessingService(QObject *parent)
    : QIviAbstractFeature(*new ProcessingServicePrivate(QLatin1String(Remote_ProcessingService_iid), this), parent)
{
}

/*! \internal */
ProcessingService::~ProcessingService()
{
}

/*! \internal */
void ProcessingService::registerQmlTypes(const QString& uri, int majorVersion, int minorVersion)
{
    qmlRegisterType<ProcessingService>(uri.toLatin1(), majorVersion, minorVersion, "UiProcessingService");
}

/*!
    \property ProcessingService::lastMessage

*/

/*!
    \qmlproperty QString UiProcessingService::lastMessage

*/
QString ProcessingService::lastMessage() const
{
    const auto d = ProcessingServicePrivate::get(this);
    if (Q_UNLIKELY(d->m_propertyOverride))
        return d->m_propertyOverride->property(metaObject()->indexOfProperty("lastMessage")).value<QString>();
    return d->m_lastMessage;
}

void ProcessingService::setLastMessage(const QString &lastMessage)
{
    auto d = ProcessingServicePrivate::get(this);
    bool forceUpdate = false;
    if (Q_UNLIKELY(d->m_propertyOverride)) {
        const int pi = metaObject()->indexOfProperty("lastMessage");
        if (d->m_propertyOverride->isOverridden(pi)) {
            emit lastMessageChanged(d->m_propertyOverride->property(pi).value<QString>());
            return;
        }
        forceUpdate = property("lastMessageDirtyOverride").isValid();
        if (forceUpdate)
            setProperty("lastMessageDirtyOverride", {});
        QVariant v = qVariantFromValue<QString>(lastMessage);
        d->m_propertyOverride->setProperty(pi, v);
    }
    if (!forceUpdate && d->m_lastMessage == lastMessage)
        return;
    if (ProcessingServiceBackendInterface *backend = processingserviceBackend())
        backend->setLastMessage(lastMessage);
    else
        emit lastMessageChanged(d->m_lastMessage);
}

/*!
    \qmlmethod UiProcessingService::process(const QString &data)

*/
/*!

*/
QIviPendingReply<int> ProcessingService::process(const QString &data)
{
    if (ProcessingServiceBackendInterface *backend = processingserviceBackend())
        return backend->process(data);
    return QIviPendingReply<int>::createFailedReply();
}

/*! \internal */
void ProcessingService::connectToServiceObject(QIviServiceObject *serviceObject)
{
    auto d = ProcessingServicePrivate::get(this);

    auto *backend = processingserviceBackend();
    if (!backend)
        return;

    QObjectPrivate::connect(backend, &ProcessingServiceBackendInterface::lastMessageChanged,
        d, &ProcessingServicePrivate::onLastMessageChanged);

    QIviAbstractFeature::connectToServiceObject(serviceObject);
}

/*! \internal */
void ProcessingService::clearServiceObject()
{
    auto d = ProcessingServicePrivate::get(this);
    d->clearToDefaults();
}

/*! \internal */
ProcessingServiceBackendInterface *ProcessingService::processingserviceBackend() const
{
    if (QIviServiceObject *so = serviceObject())
        return so->interfaceInstance<ProcessingServiceBackendInterface*>(interfaceName());
    return nullptr;
}


#include "moc_processingservice.cpp"