uavobjectmanager.cpp

Go to the documentation of this file.

/*
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program 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 General Public License
 * for more details.
 *
 * You should have received a copy of the GNU General Public License along
 * with this program; if not, see <http://www.gnu.org/licenses/>
 *
 * Additional note on redistribution: The copyright and license notices above
 * must be maintained in each individual source file that is a derivative work
 * of this source file; otherwise redistribution is prohibited.
 */
#include "uavobjectmanager.h"

UAVObjectManager::UAVObjectManager()
{
}

UAVObjectManager::~UAVObjectManager()
{
}

bool UAVObjectManager::registerObject(UAVDataObject *obj)
{
    // Check if this object type is already in the list
    quint32 objID = obj->getObjID();
    if (objects.contains(objID)) // Known object ID
    {
        if (objects.value(objID).contains(obj->getInstID())) // Instance already present
            return false;
        if (obj->isSingleInstance())
            return false;
        if (obj->getInstID() >= MAX_INSTANCES)
            return false;
        UAVDataObject *refObj = dynamic_cast<UAVDataObject *>(objects.value(objID).first());
        if (refObj == NULL) {
            return false;
        }
        UAVMetaObject *mobj = refObj->getMetaObject();
        if (objects.value(objID).last()->getInstID() < obj->getInstID()) // Space between last
                                                                         // existent instance and
                                                                         // new one, lets fill the
                                                                         // gaps
        {
            for (quint32 instidx = objects.value(objID).last()->getInstID() + 1;
                 instidx < obj->getInstID(); ++instidx) {
                UAVDataObject *cobj = obj->clone(instidx);
                cobj->initialize(instidx, mobj);
                QMap<quint32, UAVObject *> ppp;
                ppp.insert(instidx, cobj);
                objects[objID].insert(instidx, cobj);
                getObject(cobj->getObjID())->emitNewInstance(cobj); // TODO??
                emit newInstance(cobj);
            }
        } else if (obj->getInstID() == 0)
            obj->initialize(objects.value(objID).last()->getObjID() + 1, mobj);
        else {
            return false;
        }
        // Add the actual object instance in the list
        objects[objID].insert(obj->getInstID(), obj);
        getObject(objID)->emitNewInstance(obj);
        emit newInstance(obj);
        return true;
    } else {
        // If this point is reached then this is the first time this object type (ID) is added in
        // the list
        // create a new list of the instances, add in the object collection and create the object's
        // metaobject
        // Create metaobject
        QString mname = obj->getName();
        mname.append("Meta");
        UAVMetaObject *mobj = new UAVMetaObject(objID + 1, mname, obj);
        // Initialize object
        obj->initialize(0, mobj);
        // Add to list
        addObject(obj);
        addObject(mobj);
        return true;
    }
}

bool UAVObjectManager::unRegisterObject(UAVDataObject *obj)
{
    // Check if this object type is already in the list
    quint32 objID = obj->getObjID();
    if (obj->isSingleInstance())
        return false;
    quint32 instances = (quint32)objects.value(obj->getObjID()).count();
    for (quint32 x = obj->getInstID(); x < instances; ++x) {
        getObject(objects.value(objID).value(x)->getObjID())
            ->emitInstanceRemoved(objects.value(objID).value(x));
        emit instanceRemoved(objects.value(objID).value(x));
        objects[objID].remove(x);
    }
    return true;
}

void UAVObjectManager::addObject(UAVObject *obj)
{
    // Add to list
    QMap<quint32, UAVObject *> list;
    list.insert(obj->getInstID(), obj);
    objects.insert(obj->getObjID(), list);

    objectsByName.insert(obj->getName(), list);

    emit newObject(obj);
}

QVector<QVector<UAVObject *>> UAVObjectManager::getObjectsVector()
{
    QVector<QVector<UAVObject *>> vector;
    foreach (const ObjectMap &map, objects.values()) {
        QVector<UAVObject *> vec = map.values().toVector();
        vector.append(vec);
    }
    return vector;
}

QHash<quint32, QMap<quint32, UAVObject *>> UAVObjectManager::getObjects()
{
    return objects;
}

QVector<QVector<UAVDataObject *>> UAVObjectManager::getDataObjectsVector()
{
    QVector<QVector<UAVDataObject *>> vector;
    foreach (const ObjectMap &map, objects.values()) {
        UAVDataObject *obj = dynamic_cast<UAVDataObject *>(map.first());
        if (obj != NULL) {
            QVector<UAVDataObject *> vec;
            foreach (UAVObject *o, map) {
                UAVDataObject *dobj = dynamic_cast<UAVDataObject *>(o);
                if (dobj)
                    vec.append(dobj);
            }
            vector.append(vec);
        }
    }
    return vector;
}

QVector<QVector<UAVMetaObject *>> UAVObjectManager::getMetaObjectsVector()
{
    QVector<QVector<UAVMetaObject *>> vector;
    foreach (const ObjectMap &map, objects.values()) {
        UAVMetaObject *obj = dynamic_cast<UAVMetaObject *>(map.first());
        if (obj != NULL) {
            QVector<UAVMetaObject *> vec;
            foreach (UAVObject *o, map) {
                UAVMetaObject *mobj = dynamic_cast<UAVMetaObject *>(o);
                if (mobj)
                    vec.append(mobj);
            }
            vector.append(vec);
        }
    }
    return vector;
}

UAVObject *UAVObjectManager::getObject(const QString &name, quint32 instId)
{
    return getObject(name, 0, instId);
}

UAVObject *UAVObjectManager::getObject(quint32 objId, quint32 instId)
{
    return getObject(NULL, objId, instId);
}

UAVObject *UAVObjectManager::getObject(const QString &name, quint32 objId, quint32 instId)
{
    if (name != NULL) {
        if (objectsByName.contains(name)) {
            return objectsByName.value(name).value(instId);
        }

        return NULL;
    } else if (objects.contains(objId))
        return objects.value(objId).value(instId);
    return NULL;
}

QVector<UAVObject *> UAVObjectManager::getObjectInstancesVector(const QString &name)
{
    return getObjectInstancesVector(&name, 0);
}

QVector<UAVObject *> UAVObjectManager::getObjectInstancesVector(quint32 objId)
{
    return getObjectInstancesVector(NULL, objId);
}

QVector<UAVObject *> UAVObjectManager::getObjectInstancesVector(const QString *name, quint32 objId)
{
    if (name != NULL) {
        foreach (const ObjectMap &map, objects) {
            if (map.first()->getName().compare(name) == 0)
                return map.values().toVector();
        }
    } else if (objects.contains(objId))
        return objects.value(objId).values().toVector();
    return QVector<UAVObject *>();
}

qint32 UAVObjectManager::getNumInstances(const QString &name)
{
    return getNumInstances(&name, 0);
}

qint32 UAVObjectManager::getNumInstances(quint32 objId)
{
    return getNumInstances(NULL, objId);
}

qint32 UAVObjectManager::getNumInstances(const QString *name, quint32 objId)
{
    if (name != NULL) {
        foreach (const ObjectMap &map, objects) {
            if (map.first()->getName().compare(name) == 0)
                return map.count();
        }
    } else if (objects.contains(objId))
        return objects.value(objId).count();
    return -1;
}

UAVObjectField *UAVObjectManager::getField(const QString &objName, const QString &fieldName,
                                           quint32 instId)
{
    UAVObject *uavo = getObject(objName, instId);
    Q_ASSERT(uavo);
    if (!uavo)
        return nullptr;
    UAVObjectField *field = uavo->getField(fieldName);
    Q_ASSERT(field);
    return field;
}