ZScopedMap.cpp

Go to the documentation of this file.

/*
 * Zuble - A run-time system for QML/Javascript applications
 * Copyright (C) 2016 Bob Dinitto
 *
 * Filename:   ZScopedMap.cpp
 * Created on: 06-Oct-2017
 * Author:     Bob Dinitto
 *
 * Zuble 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 2.1 of the License, or (at your option) any later version.
 *
 * This library 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 this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 *
 */

#include "ZScopedMap.h"
#include <QtQml>
#include <QStringBuilder>

namespace Zbl
{

ZBL_DEFINE_LOGGED_OBJECT(Zbl::ZScopedMap)

ZScopedMap::ZScopedMap(QObject *parent) :
    QObject(parent), m_outerScope(0)
{
}

void ZScopedMap::registerType()
{
    ZBL_REGISTER_LOGGED_OBJECT

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

void ZScopedMap::setOuterScope(QObject* outerScope)
{
    // TBD: hook up connections & notify listeners

    ZScopedMap* outer = qobject_cast<ZScopedMap*>(outerScope);

    if(!outer)
    {
        zWarning() << "ZScopedMap programming error - outerScope must be a ZScopedMap object.";

        return;
    }

    if(m_outerScope)
    {
        disconnect(m_outerScope, SIGNAL(reset()), this, SIGNAL(reset()));
    }
    
    m_outerScope = outer;

    connect(m_outerScope, SIGNAL(reset()), this, SIGNAL(reset()));

}

QObject *ZScopedMap::getOuterScope()
{
    return m_outerScope;
}

void ZScopedMap::loadJSON(const QString& jsonString)
{

    if(jsonString.isEmpty())
        return;

    if(!m_JSON.isEmpty())
    {
        zWarning() << "loadJSON failed! - JSON initializer string has already been set.";

        return;
    }

    QJsonParseError er;

    QJsonDocument doc = QJsonDocument::fromJson(jsonString.toUtf8(), &er);

    if(er.error != QJsonParseError::NoError)
    {
        zWarning() << "loadJSON parse error: " << er.errorString();
        zWarning() << "JSON failed: " << jsonString;

        return;
    }

    if(!doc.isObject())
    {
        zWarning() << "loadJSON format error: " <<
                      "JSON initializer should be a JSON object of key/value pairs.";
        zWarning() << "JSON failed: " << jsonString;
    }

    QJsonObject ob = doc.object();

    QJsonObject::const_iterator i = ob.begin();

    QVariantMap tempMap;

    for(;i != ob.end(); i++)
    {
        QString key = i.key();
        QJsonValue value = *i;

        QVariant qValue(value.toVariant());


        if(isValidType(value))
            tempMap.insert(key, qValue);
    }

    m_JSON = jsonString;

    m_map = tempMap;
}

QString ZScopedMap::toJSON() const
{
    zDebug() << "Getting JSON string from scoped map.";

    QJsonDocument jdoc = QJsonDocument::fromVariant(m_map);

    QString json = jdoc.toJson();

    zDebug() << "JSON property string = " << json;

    return json;
}

QString ZScopedMap::getInitializer() const
{
    return m_JSON;
}


int ZScopedMap::getSize() const
{
    return m_map.size();
}

bool ZScopedMap::has(const QString& key) const
{
    if(m_map.contains(key))
        return true;
    else if(m_outerScope)
        return m_outerScope->has(key);
}

QVariant ZScopedMap::get(const QString& key) const
{
    if(m_map.contains(key))
        return m_map.value(key);
    else if(m_outerScope)
        return m_outerScope->get(key);
    else
        return QVariant();
}

void ZScopedMap::set(const QString& key, const QJsonValue &value)
{
    if(!isValidType(value))
        return;

    QVariant qValue = value.toVariant();

    setValue(m_map, key, qValue, true);
}

bool ZScopedMap::setValue(QVariantMap& map, const QString& key, QVariant value, bool emitSignal)
{
    if(map.contains(key))
    {
        QVariant old = m_map.value(key);

        if(old.type() == value.type() && old == value)
            return true;
    }

    zDebug() << "Modifying scoped map - key: " << key << ", value: " << value;

    map.insert(key, value);

    if(emitSignal)
        emit itemChanged(key, value);

    return true;
}

bool ZScopedMap::remove(const QString& key)
{
    return m_map.remove(key) ? true : false;
}

QVariantList ZScopedMap::keys() const
{
    // TBD: bug! need to call outer scope here - we should collect the set of
    // all keys for all enclosing scopes, eliminating duplicates.


    QList<QString> k = m_map.keys();

    const int count = k.count();

    QVariantList vk;

    for(int i=0; i<count; i++)
    {
        qDebug() << "mapkey = " << k.at(i);

        vk.append(QVariant(k.at(i)));
    }

    for(int i = 0; i<vk.count(); i++)
        qDebug() << "variant key = " << vk.at(i);

    return vk;
}

void ZScopedMap::clear()
{
    m_map.clear();
}

bool ZScopedMap::isValidType(const QJsonValue& value)
{
    switch(value.type())
    {
        case QJsonValue::Bool:
        case QJsonValue::Double:
        case QJsonValue::String:
        return true;
    }

    zWarning() << "Value type error: " <<
                  "type must be either number, boolean or string.";
    zWarning() << "Failed value: " << value.toString();
    //zWarning() << "Failed type: " <<

    return false;
}

bool ZScopedMap::isValidType(const QVariant& value)
{
    switch(value.type())
    {
        case QMetaType::Bool:
        case QMetaType::Double:
        case QMetaType::Int:
        case QMetaType::UInt:
        case QMetaType::LongLong:
        case QMetaType::ULongLong:
        case QMetaType::QString:
        return true;
    }

    zWarning() << "Value type error: " <<
                  "type must be either number, boolean or string.";
    zWarning() << "Failed value: " << value.toString();
    //zWarning() << "Failed type: " <<

    return false;
}

bool ZScopedMap::setMap(QVariantMap map)
{
    // update is transactional: all or nothing

    QVariantMap tempMap;

    QVariantMap::const_iterator i = map.begin();

    for(;i != map.end(); i++)
    {
        QVariant nextValue(i.value());

        if(!isValidType(nextValue))
            return false;

        if(!setValue(tempMap, i.key(), i.value()), false)
            return false;
    }

    if(tempMap.isEmpty())
        return false;

    i = tempMap.begin();

    for(;i != tempMap.end(); i++)
        m_map.insert(i.key(), i.value());

    emit mapChanged(tempMap);

    return true;
 }

bool ZScopedMap::setScopedMap(QObject* map)
{
    ZScopedMap* scoped = qobject_cast<ZScopedMap*>(map);

    if(!scoped)
    {
        zWarning() << "setMap invalid parameter type: object must be of type "
                      "ZScopedMap or QVariantMap (javascript native object)";
        return false;
    }

    return setMap(scoped->m_map);
}

void ZScopedMap::invalidate()
{
    zDebug() << "Emitting ZScopedMap::reset signal";

    emit reset();
}





} // Zbl