uavobjectfield.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 "uavobjectfield.h"
#include <QtEndian>
#include <QDebug>
#include <cfloat>

UAVObjectField::UAVObjectField(const QString &name, const QString &units, FieldType type,
                               int numElements, const QStringList &options,
                               const QList<int> &indices, const QString &limits,
                               const QString &description, const QList<QVariant> defaultValues,
                               const DisplayType display)
{
    QStringList elementNames;
    // Set element names
    for (auto n = 0; n < numElements; ++n) {
        elementNames.append(QString("%1").arg(n));
    }
    // Initialize
    constructorInitialize(name, units, type, elementNames, options, indices, limits, description,
                          defaultValues, display);
}

UAVObjectField::UAVObjectField(const QString &name, const QString &units, FieldType type,
                               const QStringList &elementNames, const QStringList &options,
                               const QList<int> &indices, const QString &limits,
                               const QString &description, const QList<QVariant> defaultValues,
                               const DisplayType display)
{
    constructorInitialize(name, units, type, elementNames, options, indices, limits, description,
                          defaultValues, display);
}

void UAVObjectField::constructorInitialize(const QString &name, const QString &units,
                                           FieldType type, const QStringList &elementNames,
                                           const QStringList &options, const QList<int> &indices,
                                           const QString &limits, const QString &description,
                                           const QList<QVariant> defaultValues,
                                           const DisplayType display)
{
    // Copy params
    this->name = name;
    this->units = units;
    this->type = type;
    this->options = options;
    this->indices = indices;
    this->numElements = elementNames.length();
    this->offset = 0;
    this->data = NULL;
    this->obj = NULL;
    this->elementNames = elementNames;
    this->description = description;
    this->display = display;

    // Set field size
    switch (type) {
    case INT8:
        elementSize = sizeof(qint8);
        break;
    case INT16:
        elementSize = sizeof(qint16);
        break;
    case INT32:
        elementSize = sizeof(qint32);
        break;
    case UINT8:
        elementSize = sizeof(quint8);
        break;
    case UINT16:
        elementSize = sizeof(quint16);
        break;
    case UINT32:
        elementSize = sizeof(quint32);
        break;
    case FLOAT32:
        elementSize = sizeof(quint32);
        break;
    case ENUM:
        elementSize = sizeof(quint8);
        break;
    case BITFIELD:
        elementSize = sizeof(quint8);
        this->options = QStringList() << tr("0") << tr("1");
        this->indices = QList<int>() << 0 << 1;
        break;
    case STRING:
        elementSize = sizeof(quint8);
        break;
    }
    limitsInitialize(limits);

    // store default values, default to zero when not provided
    this->defaultValues = defaultValues;
    for (auto i = this->defaultValues.length(); i < this->numElements; i++)
        this->defaultValues << QVariant(0);

    // fast lookup
    for (int i = 0; i < indices.length(); i++)
        enumToIndex.emplace(std::make_pair(indices.at(i), i));
}

void UAVObjectField::limitsInitialize(const QString &limits)
{
    if (limits.isEmpty())
        return;
    QStringList stringPerElement = limits.split(",");
    int index = 0;
    foreach (const QString &str, stringPerElement) {
        QStringList ruleList = str.split(";");
        QList<LimitStruct> limitList;
        foreach (const QString &rule, ruleList) {
            QString _str = rule.trimmed();
            if (_str.isEmpty())
                continue;
            QStringList valuesPerElement = _str.split(":");
            LimitStruct lstruc;
            bool startFlag = valuesPerElement.at(0).startsWith("%");
            bool maxIndexFlag = index < numElements;
            bool elemNumberSizeFlag = valuesPerElement.at(0).size() == 3;
            bool aux;
            valuesPerElement.at(0).mid(1, 4).toInt(&aux, 16);
            bool b4 = ((valuesPerElement.at(0).size()) == 7 && aux);
            if (startFlag && maxIndexFlag && (elemNumberSizeFlag || b4)) {
                if (b4)
                    lstruc.board = valuesPerElement.at(0).mid(1, 4).toInt(&aux, 16);
                else
                    lstruc.board = 0;
                if (valuesPerElement.at(0).right(2) == "EQ")
                    lstruc.type = EQUAL;
                else if (valuesPerElement.at(0).right(2) == "NE")
                    lstruc.type = NOT_EQUAL;
                else if (valuesPerElement.at(0).right(2) == "BE")
                    lstruc.type = BETWEEN;
                else if (valuesPerElement.at(0).right(2) == "BI")
                    lstruc.type = BIGGER;
                else if (valuesPerElement.at(0).right(2) == "SM")
                    lstruc.type = SMALLER;
                else
                    qDebug() << "limits parsing failed (invalid property) on UAVObjectField"
                             << name;
                valuesPerElement.removeAt(0);
                foreach (const QString &_value, valuesPerElement) {
                    QString value = _value.trimmed();
                    switch (type) {
                    case UINT8:
                    case UINT16:
                    case UINT32:
                    case BITFIELD:
                        lstruc.values.append((quint32)value.toULong());
                        break;
                    case INT8:
                    case INT16:
                    case INT32:
                        lstruc.values.append((qint32)value.toLong());
                        break;
                    case FLOAT32:
                        lstruc.values.append((float)value.toFloat());
                        break;
                    case ENUM:
                        lstruc.values.append((QString)value);
                        break;
                    case STRING:
                        lstruc.values.append((QString)value);
                        break;
                    default:
                        lstruc.values.append(QVariant());
                    }
                }
                limitList.append(lstruc);
            } else {
                if (!valuesPerElement.at(0).isEmpty() && !startFlag)
                    qDebug()
                        << "limits parsing failed (property doesn't start with %) on UAVObjectField"
                        << name;
                else if (!maxIndexFlag)
                    qDebug() << "limits parsing failed (index>numelements) on UAVObjectField"
                             << name << "index" << index << "numElements" << numElements;
                else if (!elemNumberSizeFlag || !b4)
                    qDebug() << "limits parsing failed limit not starting with %XX or %YYYYXX "
                                "where XX is the limit type and YYYY is the board type on "
                                "UAVObjectField"
                             << name;
            }
        }
        elementLimits.insert(index, limitList);
        ++index;
    }
}

bool UAVObjectField::isWithinLimits(QVariant var, int index, int board) const
{
    if (!elementLimits.keys().contains(index))
        return true;

    foreach (const LimitStruct &struc, elementLimits.value(index)) {
        if ((struc.board != board) && board != 0 && struc.board != 0)
            continue;
        switch (struc.type) {
        case EQUAL:
            switch (type) {
            case INT8:
            case INT16:
            case INT32:
                foreach (const QVariant &vars, struc.values) {
                    if (var.toInt() == vars.toInt())
                        return true;
                }
                return false;
                break;
            case UINT8:
            case UINT16:
            case UINT32:
            case BITFIELD:
                foreach (const QVariant &vars, struc.values) {
                    if (var.toUInt() == vars.toUInt())
                        return true;
                }
                return false;
                break;
            case ENUM:
            case STRING:
                foreach (const QVariant &vars, struc.values) {
                    if (var.toString() == vars.toString())
                        return true;
                }
                return false;
                break;
            case FLOAT32:
                foreach (const QVariant &vars, struc.values) {
                    if (var.toFloat() == vars.toFloat())
                        return true;
                }
                return false;
                break;
            default:
                return true;
            }
            break;
        case NOT_EQUAL:
            switch (type) {
            case INT8:
            case INT16:
            case INT32:
                foreach (const QVariant &vars, struc.values) {
                    if (var.toInt() == vars.toInt())
                        return false;
                }
                return true;
                break;
            case UINT8:
            case UINT16:
            case UINT32:
            case BITFIELD:
                foreach (const QVariant &vars, struc.values) {
                    if (var.toUInt() == vars.toUInt())
                        return false;
                }
                return true;
                break;
            case ENUM:
            case STRING:
                foreach (const QVariant &vars, struc.values) {
                    if (var.toString() == vars.toString())
                        return false;
                }
                return true;
                break;
            case FLOAT32:
                foreach (const QVariant &vars, struc.values) {
                    if (var.toFloat() == vars.toFloat())
                        return false;
                }
                return true;
                break;
            default:
                return true;
            }
            break;
        case BETWEEN:
            if (struc.values.length() < 2) {
                qDebug() << __FUNCTION__
                         << "between limit with less than 1 pair, aborting; field:" << name;
                return true;
            }
            if (struc.values.length() > 2)
                qDebug() << __FUNCTION__
                         << "between limit with more than 1 pair, using first; field" << name;
            switch (type) {
            case INT8:
            case INT16:
            case INT32:
                if (!(var.toInt() >= struc.values.at(0).toInt()
                      && var.toInt() <= struc.values.at(1).toInt()))
                    return false;
                return true;
                break;
            case UINT8:
            case UINT16:
            case UINT32:
            case BITFIELD:
                if (!(var.toUInt() >= struc.values.at(0).toUInt()
                      && var.toUInt() <= struc.values.at(1).toUInt()))
                    return false;
                return true;
                break;
            case ENUM:
                // OK, I think this is OK with parents.  Because we'll
                // consider the limit to mean "as ordered in this object".
                // So no need to map to underlying types.
                if (!(options.indexOf(var.toString())
                          >= options.indexOf(struc.values.at(0).toString())
                      && options.indexOf(var.toString())
                          <= options.indexOf(struc.values.at(1).toString())))
                    return false;
                return true;
                break;
            case STRING:
                return true;
                break;
            case FLOAT32:
                if (!(var.toFloat() >= struc.values.at(0).toFloat()
                      && var.toFloat() <= struc.values.at(1).toFloat()))
                    return false;
                return true;
                break;
            default:
                return true;
            }
            break;
        case BIGGER:
            if (struc.values.length() < 1) {
                qDebug() << __FUNCTION__
                         << "BIGGER limit with less than 1 value, aborting; field:" << name;
                return true;
            }
            if (struc.values.length() > 1)
                qDebug() << __FUNCTION__
                         << "BIGGER limit with more than 1 value, using first; field" << name;
            switch (type) {
            case INT8:
            case INT16:
            case INT32:
                if (!(var.toInt() >= struc.values.at(0).toInt()))
                    return false;
                return true;
                break;
            case UINT8:
            case UINT16:
            case UINT32:
            case BITFIELD:
                if (!(var.toUInt() >= struc.values.at(0).toUInt()))
                    return false;
                return true;
                break;
            case ENUM:
                if (!(options.indexOf(var.toString())
                      >= options.indexOf(struc.values.at(0).toString())))
                    return false;
                return true;
                break;
            case STRING:
                return true;
                break;
            case FLOAT32:
                if (!(var.toFloat() >= struc.values.at(0).toFloat()))
                    return false;
                return true;
                break;
            default:
                return true;
            }
            break;
        case SMALLER:
            switch (type) {
            case INT8:
            case INT16:
            case INT32:
                if (!(var.toInt() <= struc.values.at(0).toInt()))
                    return false;
                return true;
                break;
            case UINT8:
            case UINT16:
            case UINT32:
            case BITFIELD:
                if (!(var.toUInt() <= struc.values.at(0).toUInt()))
                    return false;
                return true;
                break;
            case ENUM:
                if (!(options.indexOf(var.toString())
                      <= options.indexOf(struc.values.at(0).toString())))
                    return false;
                return true;
                break;
            case STRING:
                return true;
                break;
            case FLOAT32:
                if (!(var.toFloat() <= struc.values.at(0).toFloat()))
                    return false;
                return true;
                break;
            default:
                return true;
            }
        }
    }
    return true;
}

QVariant UAVObjectField::getMaxLimit(int index, int board) const
{
    if (!elementLimits.keys().contains(index)) {
        // if nothing explicitly specified, assume max possible value
        switch (type) {
        case INT8:
            return INT8_MAX;
        case INT16:
            return INT16_MAX;
        case INT32:
            return INT32_MAX;
        case UINT8:
            return UINT8_MAX;
        case UINT16:
            return UINT16_MAX;
        case UINT32:
            return UINT32_MAX;
        case FLOAT32:
            return FLT_MAX;
        case ENUM: // TODO: could do better for this one
        case BITFIELD:
        case STRING:
            break;
        }
        return QVariant();
    }

    foreach (const LimitStruct &struc, elementLimits.value(index)) {
        if ((struc.board != board) && board != 0 && struc.board != 0)
            continue;
        switch (struc.type) {
        case EQUAL:
        case NOT_EQUAL:
        case BIGGER:
            return QVariant();
            break;
            break;
        case BETWEEN:
            return struc.values.at(1);
            break;
        case SMALLER:
            return struc.values.at(0);
            break;
        default:
            return QVariant();
            break;
        }
    }
    return QVariant();
}
QVariant UAVObjectField::getMinLimit(int index, int board) const
{
    if (!elementLimits.keys().contains(index)) {
        // if nothing explicitly specified, assume min possible value
        switch (type) {
        case INT8:
            return INT8_MIN;
        case INT16:
            return INT16_MIN;
        case INT32:
            return INT32_MIN;
        case UINT8:
        case UINT16:
        case UINT32:
            return 0;
        case FLOAT32:
            return FLT_MIN;
        case ENUM: // TODO: could do better for this one
        case BITFIELD:
        case STRING:
            break;
        }
        return QVariant();
    }

    foreach (LimitStruct struc, elementLimits.value(index)) {
        if ((struc.board != board) && board != 0 && struc.board != 0)
            return QVariant();
        switch (struc.type) {
        case EQUAL:
        case NOT_EQUAL:
        case SMALLER:
            return QVariant();
            break;
            break;
        case BETWEEN:
            return struc.values.at(0);
            break;
        case BIGGER:
            return struc.values.at(0);
            break;
        default:
            return QVariant();
            break;
        }
    }
    return QVariant();
}
void UAVObjectField::initialize(quint8 *data, quint32 dataOffset, UAVObject *obj)
{
    this->data = data;
    this->offset = dataOffset;
    this->obj = obj;
    clear();
}

UAVObjectField::FieldType UAVObjectField::getType() const
{
    return type;
}

QString UAVObjectField::getTypeAsString() const
{
    switch (type) {
    case UAVObjectField::INT8:
        return "int8";
    case UAVObjectField::INT16:
        return "int16";
    case UAVObjectField::INT32:
        return "int32";
    case UAVObjectField::UINT8:
        return "uint8";
    case UAVObjectField::UINT16:
        return "uint16";
    case UAVObjectField::UINT32:
        return "uint32";
    case UAVObjectField::FLOAT32:
        return "float32";
    case UAVObjectField::ENUM:
        return "enum";
    case UAVObjectField::BITFIELD:
        return "bitfield";
    case UAVObjectField::STRING:
        return "string";
    default:
        return "";
    }
}

QStringList UAVObjectField::getElementNames() const
{
    return elementNames;
}

QString UAVObjectField::getElementName(int index) const
{
    if (index < 0 || index >= elementNames.length()) {
        Q_ASSERT(false);
        qWarning() << "Invalid element:" << index << " max=" << elementNames.length();
        return "";
    }
    return elementNames.at(index);
}

int UAVObjectField::getElementIndex(const QString &name) const
{
    for (int i = 0; i < elementNames.length(); i++) {
        if (elementNames.at(i) == name)
            return i;
    }
    return -1;
}

UAVObject *UAVObjectField::getObject() const
{
    return obj;
}

void UAVObjectField::clear()
{
    switch (type) {
    case BITFIELD:
        memset(&data[offset], 0, elementSize * ((quint32)(1 + (numElements - 1) / 8)));
        break;
    default:
        memset(&data[offset], 0, elementSize * numElements);
        break;
    }
}

QString UAVObjectField::getName() const
{
    return name;
}

QString UAVObjectField::getUnits() const
{
    return units;
}

QStringList UAVObjectField::getOptions() const
{
    return options;
}

bool UAVObjectField::hasOption(const QString &option)
{
    return options.contains(option);
}

int UAVObjectField::getNumElements() const
{
    return numElements;
}

size_t UAVObjectField::getNumBytes() const
{
    if (type == BITFIELD)
        return elementSize * static_cast<size_t>((1 + (numElements - 1) / 8));
    return elementSize * static_cast<size_t>(numElements);
}

QString UAVObjectField::toString() const
{
    QString sout;
    sout.append(QString("%1: [ ").arg(name));
    for (auto n = 0; n < numElements; ++n) {
        if (type == ENUM) {
            sout.append(QString("%1 ").arg(getValue(n).toString()));
        } else {
            sout.append(QString("%1 ").arg(getDouble(n)));
        }
    }
    sout.append(QString("] %1\n").arg(units));
    return sout;
}

qint32 UAVObjectField::pack(quint8 *dataOut)
{
    // Pack each element in output buffer
    switch (type) {
    case INT8:
        memcpy(dataOut, &data[offset], numElements);
        break;
    case INT16:
        for (auto index = 0; index < numElements; ++index) {
            qint16 value;
            memcpy(&value, &data[offset + elementSize * index], elementSize);
            qToLittleEndian<qint16>(value, &dataOut[elementSize * index]);
        }
        break;
    case INT32:
        for (auto index = 0; index < numElements; ++index) {
            qint32 value;
            memcpy(&value, &data[offset + elementSize * index], elementSize);
            qToLittleEndian<qint32>(value, &dataOut[elementSize * index]);
        }
        break;
    case UINT8:
        for (auto index = 0; index < numElements; ++index) {
            dataOut[elementSize * index] = data[offset + elementSize * index];
        }
        break;
    case UINT16:
        for (auto index = 0; index < numElements; ++index) {
            quint16 value;
            memcpy(&value, &data[offset + elementSize * index], elementSize);
            qToLittleEndian<quint16>(value, &dataOut[elementSize * index]);
        }
        break;
    case UINT32:
        for (auto index = 0; index < numElements; ++index) {
            quint32 value;
            memcpy(&value, &data[offset + elementSize * index], elementSize);
            qToLittleEndian<quint32>(value, &dataOut[elementSize * index]);
        }
        break;
    case FLOAT32:
        for (auto index = 0; index < numElements; ++index) {
            quint32 value;
            memcpy(&value, &data[offset + elementSize * index], elementSize);
            qToLittleEndian<quint32>(value, &dataOut[elementSize * index]);
        }
        break;
    case ENUM:
        for (auto index = 0; index < numElements; ++index) {
            dataOut[elementSize * index] = data[offset + elementSize * index];
        }
        break;
    case BITFIELD:
        for (auto index = 0; index < (1 + (numElements - 1) / 8); ++index) {
            dataOut[elementSize * index] = data[offset + elementSize * index];
        }
        break;
    case STRING:
        memcpy(dataOut, &data[offset], numElements);
        break;
    }
    // Done
    return getNumBytes();
}

qint32 UAVObjectField::unpack(const quint8 *dataIn)
{
    // Unpack each element from input buffer
    switch (type) {
    case INT8:
        memcpy(&data[offset], dataIn, numElements);
        break;
    case INT16:
        for (auto index = 0; index < numElements; ++index) {
            qint16 value;
            value = qFromLittleEndian<qint16>(&dataIn[elementSize * index]);
            memcpy(&data[offset + elementSize * index], &value, elementSize);
        }
        break;
    case INT32:
        for (auto index = 0; index < numElements; ++index) {
            qint32 value;
            value = qFromLittleEndian<qint32>(&dataIn[elementSize * index]);
            memcpy(&data[offset + elementSize * index], &value, elementSize);
        }
        break;
    case UINT8:
        for (auto index = 0; index < numElements; ++index) {
            data[offset + elementSize * index] = dataIn[elementSize * index];
        }
        break;
    case UINT16:
        for (auto index = 0; index < numElements; ++index) {
            quint16 value;
            value = qFromLittleEndian<quint16>(&dataIn[elementSize * index]);
            memcpy(&data[offset + elementSize * index], &value, elementSize);
        }
        break;
    case UINT32:
        for (auto index = 0; index < numElements; ++index) {
            quint32 value;
            value = qFromLittleEndian<quint32>(&dataIn[elementSize * index]);
            memcpy(&data[offset + elementSize * index], &value, elementSize);
        }
        break;
    case FLOAT32:
        for (auto index = 0; index < numElements; ++index) {
            quint32 value;
            value = qFromLittleEndian<quint32>(&dataIn[elementSize * index]);
            memcpy(&data[offset + elementSize * index], &value, elementSize);
        }
        break;
    case ENUM:
        for (auto index = 0; index < numElements; ++index) {
            data[offset + elementSize * index] = dataIn[elementSize * index];
        }
        break;
    case BITFIELD:
        for (auto index = 0; index < (1 + (numElements - 1) / 8); ++index) {
            data[offset + elementSize * index] = dataIn[elementSize * index];
        }
        break;
    case STRING:
        memcpy(&data[offset], dataIn, numElements);
        break;
    }
    // Done
    return getNumBytes();
}

bool UAVObjectField::isNumeric() const
{
    switch (type) {
    case INT8:
    case INT16:
    case INT32:
    case UINT8:
    case UINT16:
    case UINT32:
    case FLOAT32:
    case BITFIELD:
        return true;
    case ENUM:
    case STRING:
        break;
    }
    return false;
}

bool UAVObjectField::isText() const
{
    switch (type) {
    case INT8:
    case INT16:
    case INT32:
    case UINT8:
    case UINT16:
    case UINT32:
    case FLOAT32:
    case BITFIELD:
        return false;
    case ENUM:
    case STRING:
        break;
    }
    return true;
}

QVariant UAVObjectField::getValue(int index) const
{
    // Check that index is not out of bounds
    if (index < 0 || index >= numElements) {
        return QVariant();
    }

    const void *d = &data[offset + elementSize * static_cast<unsigned>(index)];

    switch (type) {
    case INT8:
        // QVariant treats qint8 as char :(
        return QVariant::fromValue(static_cast<int>(*static_cast<const qint8 *>(d)));
    case INT16:
        return QVariant::fromValue(*static_cast<const qint16 *>(d));
    case INT32:
        return QVariant::fromValue(*static_cast<const qint32 *>(d));
    case UINT8:
        // QVariant treats quint8 as char :(
        return QVariant::fromValue(static_cast<int>(*static_cast<const quint8 *>(d)));
    case UINT16:
        return QVariant::fromValue(*static_cast<const quint16 *>(d));
    case UINT32:
        return QVariant::fromValue(*static_cast<const quint32 *>(d));
    case FLOAT32:
        return QVariant::fromValue(*static_cast<const float *>(d));
    case ENUM:
        try {
            auto i = enumToIndex.at(*static_cast<const quint8 *>(d));
            return QVariant::fromValue(options[i]);
        } catch (const std::out_of_range &e) {
            qWarning() << "Invalid value" << *static_cast<const quint8 *>(d)
                       << "for ENUM field" << name << ":" << e.what();
        }
        return QVariant::fromValue(QStringLiteral("Bad Value"));
    case BITFIELD: {
        d = &data[offset + elementSize * static_cast<unsigned>(index / 8)];
        quint8 val = (*static_cast<const quint8 *>(d) >> (index % 8)) & 1;
        return QVariant::fromValue(val > 0 ? QChar('1') : QChar('0'));
    }
    case STRING:
        return QVariant::fromValue(QString::fromLatin1(static_cast<const char *>(d),
            static_cast<int>(strnlen(static_cast<const char *>(d),
                                     static_cast<size_t>(numElements)))));
    }
    // If this point is reached then we got an invalid type
    Q_ASSERT(false);
    return QVariant();
}

bool UAVObjectField::checkValue(const QVariant &value, int index) const
{
    // Check that index is not out of bounds
    if (index < 0 || index >= numElements) {
        return false;
    }
    // Get metadata
    UAVObject::Metadata mdata = obj->getMetadata();
    // Update value if the access mode permits
    if (UAVObject::GetFlightAccess(mdata) == UAVObject::ACCESS_READWRITE) {
        switch (type) {
        case INT8:
        case INT16:
        case INT32:
        case UINT8:
        case UINT16:
        case UINT32:
        case FLOAT32:
        case STRING:
        case BITFIELD:
            return true;
        case ENUM:
            if (static_cast<QMetaType::Type>(value.type()) == QMetaType::QString) {
                int idx = options.indexOf(value.toString());
                if (idx >= 0 && idx < indices.length())
                    return true;
            } else if (value.canConvert(QMetaType::Int)) {
                if (indices.contains(value.toInt()))
                    return true;
            }
            return false;
        }
    }
    return true;
}

void UAVObjectField::setValue(const QVariant &value, int index)
{
    // Check that index is not out of bounds
    if (index < 0 || index >= numElements) {
        return;
    }

    void *d = &data[offset + elementSize * static_cast<unsigned>(index)];

    // Get metadata
    UAVObject::Metadata mdata = obj->getMetadata();
    // Update value if the access mode permits
    if (UAVObject::GetGcsAccess(mdata) == UAVObject::ACCESS_READWRITE) {
        switch (type) {
        case INT8:
            *static_cast<qint8 *>(d) = static_cast<qint8>(value.toInt());
            break;
        case INT16:
            *static_cast<qint16 *>(d) = static_cast<qint16>(value.toInt());
            break;
        case INT32:
            *static_cast<qint32 *>(d) = static_cast<qint32>(value.toInt());
            break;
        case UINT8:
            *static_cast<quint8 *>(d) = static_cast<quint8>(value.toUInt());
            break;
        case UINT16:
            *static_cast<quint16 *>(d) = static_cast<quint16>(value.toUInt());
            break;
        case UINT32:
            *static_cast<quint32 *>(d) = static_cast<quint32>(value.toUInt());
            break;
        case FLOAT32:
            *static_cast<float *>(d) = value.toFloat();
            break;
        case ENUM:
            if (static_cast<QMetaType::Type>(value.type()) == QMetaType::QString) {
                int idx = options.indexOf(value.toString());
                if (idx < 0 || idx >= indices.length()) {
                    Q_ASSERT(false);
                    qWarning() << "Invalid option!" << obj->getName() << name << value.toString();
                    return;
                }
                *static_cast<quint8 *>(d) = static_cast<quint8>(indices[idx]);
            } else if (value.canConvert(QMetaType::Int)) {
                if (!indices.contains(value.toInt())) {
                    Q_ASSERT(false);
                    qWarning() << "Invalid option!" << obj->getName() << name << value.toInt();
                    return;
                }
                *static_cast<quint8 *>(d) = static_cast<quint8>(value.toInt());
            } else {
                Q_ASSERT(false);
                qWarning() << "Invalid type!" << obj->getName() << name << value;
                return;
            }
            break;
        case BITFIELD:
            d = &data[offset + elementSize * static_cast<unsigned>(index / 8)];
            *static_cast<quint8 *>(d) &= ~(1 << (index % 8));
            *static_cast<quint8 *>(d) |= ((value.toUInt() != 0 ? 1 : 0) << (index % 8));
            break;
        case STRING: {
            QByteArray barray = value.toString().toLatin1();
            barray.resize(numElements);
            barray[numElements - 1] = '\0';
            memcpy(d, barray.constData(), static_cast<size_t>(numElements));
            break;
        }
        }
    }
}

double UAVObjectField::getDouble(int index) const
{
    return getValue(index).toDouble();
}

void UAVObjectField::setDouble(double value, int index)
{
    setValue(QVariant(value), index);
}

QString UAVObjectField::getDescription() const
{
    return description;
}

QVariant UAVObjectField::getDefaultValue(int index) const
{
    return defaultValues.at(index);
}

bool UAVObjectField::isDefaultValue(int index)
{
    switch (type) {
    case INT8:
    case INT16:
    case INT32: {
        int val = getValue(index).toInt();
        int defVal = getDefaultValue(index).toInt();
        return val == defVal;
    }
    case BITFIELD:
    case UINT8:
    case UINT16:
    case UINT32: {
        unsigned val = getValue(index).toUInt();
        unsigned defVal = getDefaultValue(index).toUInt();
        return val == defVal;
    }
    case FLOAT32: {
        float val = getValue(index).toFloat();
        float defVal = getDefaultValue(index).toFloat();
        return qFuzzyCompare(val, defVal);
    }
    case ENUM:
    case STRING: {
        const QString val = getValue(index).toString();
        const QString defVal = getDefaultValue(index).toString();
        return val == defVal;
    }
    }

    Q_ASSERT(false);
    return false;
}

int UAVObjectField::getDisplayIntegerBase() const
{
    switch (display) {
    case HEX:
        return 16;
    case BIN:
        return 2;
    case OCT:
        return 8;
    default:
        return 10;
    }
}

QString UAVObjectField::getDisplayPrefix() const
{
    switch (display) {
    case HEX:
        return QStringLiteral("0x");
    case BIN:
        return QStringLiteral("0b");
    case OCT:
        return QStringLiteral("0");
    default:
        return QString();
    }
}