QDeclarativeListModelParser Class Reference

#include <qdeclarativelistmodel_p.h>

Inheritance diagram for QDeclarativeListModelParser:

Classes
struct	ListInstruction
struct	ListModelData

Public Functions
QByteArray	compile (const QList< QDeclarativeCustomParserProperty > &)
void	setCustomData (QObject *, const QByteArray &)
Public Functions inherited from QDeclarativeCustomParser
void	clearErrors ()
QList< QDeclarativeError >	errors () const
Flags	flags () const
	QDeclarativeCustomParser ()
	QDeclarativeCustomParser (Flags f)
virtual	~QDeclarativeCustomParser ()

Private Functions
bool	compileProperty (const QDeclarativeCustomParserProperty &prop, QList< ListInstruction > &instr, QByteArray &data)
bool	definesEmptyList (const QString &)

Properties
QByteArray	listElementTypeName

Additional Inherited Members
Public Types inherited from QDeclarativeCustomParser
enum	Flag { NoFlag = 0x00000000, AcceptsAttachedProperties = 0x00000001 }
Protected Functions inherited from QDeclarativeCustomParser
void	error (const QString &description)
	Reports an error with the given description. More...
void	error (const QDeclarativeCustomParserProperty &, const QString &description)
	Reports an error in parsing prop, with the given description. More...
void	error (const QDeclarativeCustomParserNode &, const QString &description)
	Reports an error in parsing node, with the given description. More...
int	evaluateEnum (const QByteArray &) const
	If script is a simply enum expression (eg. More...
const QMetaObject *	resolveType (const QByteArray &) const
	Resolves name to a type, or 0 if it is not a type. More...
QDeclarativeBinding::Identifier	rewriteBinding (const QString &, const QByteArray &)
	Rewrites expression and returns an identifier that can be used to construct the binding later. More...

Detailed Description

Definition at line 125 of file qdeclarativelistmodel_p.h.

Functions

compile()

QByteArray QDeclarativeListModelParser::compile ( const QList< QDeclarativeCustomParserProperty > &  customProps )

virtual

Implements QDeclarativeCustomParser.

Definition at line 781 of file qdeclarativelistmodel.cpp.

{
    QList<ListInstruction> instr;
    QByteArray data;
    listElementTypeName = QByteArray(); // unknown

    for(int ii = 0; ii < customProps.count(); ++ii) {
        const QDeclarativeCustomParserProperty &prop = customProps.at(ii);
        if(!prop.name().isEmpty()) { // isn't default property
            error(prop, QDeclarativeListModel::tr("ListModel: undefined property '%1'").arg(QString::fromUtf8(prop.name())));
            return QByteArray();
        }

        if(!compileProperty(prop, instr, data)) {
            return QByteArray();
        }
    }

    int size = sizeof(ListModelData) +
               instr.count() * sizeof(ListInstruction) +
               data.count();

    QByteArray rv;
    rv.resize(size);

    ListModelData *lmd = (ListModelData *)rv.data();
    lmd->dataOffset = sizeof(ListModelData) +
                     instr.count() * sizeof(ListInstruction);
    lmd->instrCount = instr.count();
    for (int ii = 0; ii < instr.count(); ++ii)
        lmd->instructions()[ii] = instr.at(ii);
    ::memcpy(rv.data() + lmd->dataOffset, data.constData(), data.count());

    return rv;
}

compileProperty()

bool QDeclarativeListModelParser::compileProperty ( const QDeclarativeCustomParserProperty &  prop, QList< ListInstruction > &  instr, QByteArray &  data  )

private

Definition at line 670 of file qdeclarativelistmodel.cpp.

{
    QList<QVariant> values = prop.assignedValues();
    for(int ii = 0; ii < values.count(); ++ii) {
        const QVariant &value = values.at(ii);

        if(value.userType() == qMetaTypeId<QDeclarativeCustomParserNode>()) {
            QDeclarativeCustomParserNode node =
                qvariant_cast<QDeclarativeCustomParserNode>(value);

            if (node.name() != listElementTypeName) {
                const QMetaObject *mo = resolveType(node.name());
                if (mo != &QDeclarativeListElement::staticMetaObject) {
                    error(node, QDeclarativeListModel::tr("ListElement: cannot contain nested elements"));
                    return false;
                }
                listElementTypeName = node.name(); // cache right name for next time
            }

            {
            ListInstruction li;
            li.type = ListInstruction::Push;
            li.dataIdx = -1;
            instr << li;
            }

            QList<QDeclarativeCustomParserProperty> props = node.properties();
            for(int jj = 0; jj < props.count(); ++jj) {
                const QDeclarativeCustomParserProperty &nodeProp = props.at(jj);
                if (nodeProp.name().isEmpty()) {
                    error(nodeProp, QDeclarativeListModel::tr("ListElement: cannot contain nested elements"));
                    return false;
                }
                if (nodeProp.name() == "id") {
                    error(nodeProp, QDeclarativeListModel::tr("ListElement: cannot use reserved \"id\" property"));
                    return false;
                }

                ListInstruction li;
                int ref = data.count();
                data.append(nodeProp.name());
                data.append('\0');
                li.type = ListInstruction::Set;
                li.dataIdx = ref;
                instr << li;

                if(!compileProperty(nodeProp, instr, data))
                    return false;

                li.type = ListInstruction::Pop;
                li.dataIdx = -1;
                instr << li;
            }

            {
            ListInstruction li;
            li.type = ListInstruction::Pop;
            li.dataIdx = -1;
            instr << li;
            }

        } else {

            QDeclarativeParser::Variant variant =
                qvariant_cast<QDeclarativeParser::Variant>(value);

            int ref = data.count();

            QByteArray d;
            d += char(variant.type()); // type tag
            if (variant.isString()) {
                d += variant.asString().toUtf8();
            } else if (variant.isNumber()) {
                double temp = variant.asNumber();
                d += QByteArray( reinterpret_cast<const char*>(&temp), sizeof(double));
            } else if (variant.isBoolean()) {
                d += char(variant.asBoolean());
            } else if (variant.isScript()) {
                if (definesEmptyList(variant.asScript())) {
                    d[0] = char(QDeclarativeParser::Variant::Invalid); // marks empty list
                } else {
                    QByteArray script = variant.asScript().toUtf8();
                    int v = evaluateEnum(script);
                    if (v<0) {
                        if (script.startsWith("QT_TR_NOOP(\"") && script.endsWith("\")")) {
                            d[0] = char(QDeclarativeParser::Variant::String);
                            d += script.mid(12,script.length()-14);
                        } else {
                            error(prop, QDeclarativeListModel::tr("ListElement: cannot use script for property value"));
                            return false;
                        }
                    } else {
                        d[0] = char(QDeclarativeParser::Variant::Number);
                        double temp = v;
                        d += QByteArray( reinterpret_cast<const char*>(&temp), sizeof(double));
                    }
                }
            }
            d.append('\0');
            data.append(d);

            ListInstruction li;
            li.type = ListInstruction::Value;
            li.dataIdx = ref;
            instr << li;
        }
    }

    return true;
}

definesEmptyList()

bool QDeclarativeListModelParser::definesEmptyList ( const QString &  s )

private

Definition at line 896 of file qdeclarativelistmodel.cpp.

{
    if (s.startsWith(QLatin1Char('[')) && s.endsWith(QLatin1Char(']'))) {
        for (int i=1; i<s.length()-1; i++) {
            if (!s[i].isSpace())
                return false;
        }
        return true;
    }
    return false;
}

setCustomData()

void QDeclarativeListModelParser::setCustomData ( QObject *  obj, const QByteArray &  d  )

virtual

Implements QDeclarativeCustomParser.

Definition at line 817 of file qdeclarativelistmodel.cpp.

{
    QDeclarativeListModel *rv = static_cast<QDeclarativeListModel *>(obj);
    ModelNode *root = new ModelNode(rv->m_nested);
    rv->m_nested->m_ownsRoot = true;
    rv->m_nested->_root = root;
    QStack<ModelNode *> nodes;
    nodes << root;

    bool processingSet = false;

    const ListModelData *lmd = (const ListModelData *)d.constData();
    const char *data = ((const char *)lmd) + lmd->dataOffset;

    for (int ii = 0; ii < lmd->instrCount; ++ii) {
        const ListInstruction &instr = lmd->instructions()[ii];

        switch(instr.type) {
        case ListInstruction::Push:
            {
                ModelNode *n = nodes.top();
                ModelNode *n2 = new ModelNode(rv->m_nested);
                n->values << QVariant::fromValue(n2);
                nodes.push(n2);
                if (processingSet)
                    n->isArray = true;
            }
            break;

        case ListInstruction::Pop:
            nodes.pop();
            break;

        case ListInstruction::Value:
            {
                ModelNode *n = nodes.top();
                switch (QDeclarativeParser::Variant::Type(data[instr.dataIdx])) {
                 case QDeclarativeParser::Variant::Invalid:
                    n->isArray = true;
                    break;
                 case QDeclarativeParser::Variant::Boolean:
                    n->values.append(bool(data[1 + instr.dataIdx]));
                    break;
                 case QDeclarativeParser::Variant::Number:
                    double temp;
                    ::memcpy(&temp, data + 1 + instr.dataIdx, sizeof(double));
                    n->values.append(temp);
                    break;
                 case QDeclarativeParser::Variant::String:
                    n->values.append(QString::fromUtf8(data + 1 + instr.dataIdx));
                    break;
                 default:
                    Q_ASSERT("Format error in ListInstruction");
                }

                processingSet = false;
            }
            break;

        case ListInstruction::Set:
            {
                ModelNode *n = nodes.top();
                ModelNode *n2 = new ModelNode(rv->m_nested);
                n->properties.insert(QString::fromUtf8(data + instr.dataIdx), n2);
                nodes.push(n2);
                processingSet = true;
            }
            break;
        }
    }

    ModelNode *rootNode = rv->m_nested->_root;
    for (int i=0; i<rootNode->values.count(); ++i) {
        ModelNode *node = qvariant_cast<ModelNode *>(rootNode->values[i]);
        node->listIndex = i;
        node->updateListIndexes();
    }
}

Properties

listElementTypeName

QByteArray QDeclarativeListModelParser::listElementTypeName

private

Definition at line 147 of file qdeclarativelistmodel_p.h.

---

The documentation for this class was generated from the following files:

• /src/declarative/util/qdeclarativelistmodel_p.h
• /src/declarative/util/qdeclarativelistmodel.cpp