/****************************************************************************

**

** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).

** All rights reserved.

** Contact: Nokia Corporation (qt-info@nokia.com)

**

** This file is part of the QtDeclarative module of the Qt Toolkit.

**

** $QT_BEGIN_LICENSE:LGPL$

** No Commercial Usage

** This file contains pre-release code and may not be distributed.

** You may use this file in accordance with the terms and conditions

** contained in the Technology Preview License Agreement accompanying

** this package.

**

** GNU Lesser General Public License Usage

** Alternatively, this file may be used under the terms of the GNU Lesser

** General Public License version 2.1 as published by the Free Software

** Foundation and appearing in the file LICENSE.LGPL included in the

** packaging of this file.  Please review the following information to

** ensure the GNU Lesser General Public License version 2.1 requirements

** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

**

** In addition, as a special exception, Nokia gives you certain additional

** rights.  These rights are described in the Nokia Qt LGPL Exception

** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

**

** If you have questions regarding the use of this file, please contact

** Nokia at qt-info@nokia.com.

**

**

**

**

**

**

**

**

** $QT_END_LICENSE$

**

****************************************************************************/

#include "private/qmetaobjectbuilder_p.h"

#ifndef Q_OS_WIN

#include <stdint.h>

#endif

QT_BEGIN_NAMESPACE

/*!

    \class QMetaObjectBuilder

    \internal

    \brief The QMetaObjectBuilder class supports building QMetaObject objects at runtime.

*/

/*!

    \enum QMetaObjectBuilder::AddMember

    This enum defines which members of QMetaObject should be copied by QMetaObjectBuilder::addMetaObject()

    \value ClassName Add the class name.

    \value SuperClass Add the super class.

    \value Methods Add methods that aren't signals or slots.

    \value Signals Add signals.

    \value Slots Add slots.

    \value Constructors Add constructors.

    \value Properties Add properties.

    \value Enumerators Add enumerators.

    \value ClassInfos Add items of class information.

    \value RelatedMetaObjects Add related meta objects.

    \value StaticMetacall Add the static metacall function.

    \value PublicMethods Add public methods (ignored for signals).

    \value ProtectedMethods Add protected methods (ignored for signals).

    \value PrivateMethods All private methods (ignored for signals).

    \value AllMembers Add all members.

    \value AllPrimaryMembers Add everything except the class name, super class, and static metacall function.

*/

// copied from moc's generator.cpp

uint qvariant_nameToType(const char* name)

{

    if (!name)

        return 0;

    if (strcmp(name, "QVariant") == 0)

        return 0xffffffff;

    if (strcmp(name, "QCString") == 0)

        return QMetaType::QByteArray;

    if (strcmp(name, "Q_LLONG") == 0)

        return QMetaType::LongLong;

    if (strcmp(name, "Q_ULLONG") == 0)

        return QMetaType::ULongLong;

    if (strcmp(name, "QIconSet") == 0)

        return QMetaType::QIcon;

    uint tp = QMetaType::type(name);

    return tp < QMetaType::User ? tp : 0;

}

/*

  Returns true if the type is a QVariant types.

*/

bool isVariantType(const char* type)

{

    return qvariant_nameToType(type) != 0;

}

// copied from qmetaobject.cpp

// do not touch without touching the moc as well

enum PropertyFlags  {

    Invalid = 0x00000000,

    Readable = 0x00000001,

    Writable = 0x00000002,

    Resettable = 0x00000004,

    EnumOrFlag = 0x00000008,

    StdCppSet = 0x00000100,

//    Override = 0x00000200,

    Designable = 0x00001000,

    ResolveDesignable = 0x00002000,

    Scriptable = 0x00004000,

    ResolveScriptable = 0x00008000,

    Stored = 0x00010000,

    ResolveStored = 0x00020000,

    Editable = 0x00040000,

    ResolveEditable = 0x00080000,

    User = 0x00100000,

    ResolveUser = 0x00200000,

    Notify = 0x00400000,

    Dynamic = 0x00800000

};

enum MethodFlags  {

    AccessPrivate = 0x00,

    AccessProtected = 0x01,

    AccessPublic = 0x02,

    AccessMask = 0x03, //mask

    MethodMethod = 0x00,

    MethodSignal = 0x04,

    MethodSlot = 0x08,

    MethodConstructor = 0x0c,

    MethodTypeMask = 0x0c,

    MethodCompatibility = 0x10,

    MethodCloned = 0x20,

    MethodScriptable = 0x40

};

struct QMetaObjectPrivate

{

    int revision;

    int className;

    int classInfoCount, classInfoData;

    int methodCount, methodData;

    int propertyCount, propertyData;

    int enumeratorCount, enumeratorData;

    int constructorCount, constructorData;

    int flags;

};

static inline const QMetaObjectPrivate *priv(const uint* data)

{ return reinterpret_cast<const QMetaObjectPrivate*>(data); }

// end of copied lines from qmetaobject.cpp

class QMetaMethodBuilderPrivate

{

public:

    QMetaMethodBuilderPrivate

            (QMetaMethod::MethodType _methodType,

             const QByteArray& _signature,

             const QByteArray& _returnType = QByteArray(),

             QMetaMethod::Access _access = QMetaMethod::Public)

        : signature(QMetaObject::normalizedSignature(_signature.constData())),

          returnType(QMetaObject::normalizedType(_returnType)),

          attributes(((int)_access) | (((int)_methodType) << 2))

    {

    }

    QByteArray signature;

    QByteArray returnType;

    QList<QByteArray> parameterNames;

    QByteArray tag;

    int attributes;

    QMetaMethod::MethodType methodType() const

    {

        return (QMetaMethod::MethodType)((attributes & MethodTypeMask) >> 2);

    }

    QMetaMethod::Access access() const

    {

        return (QMetaMethod::Access)(attributes & AccessMask);

    }

    void setAccess(QMetaMethod::Access value)

    {

        attributes = ((attributes & ~AccessMask) | (int)value);

    }

};

class QMetaPropertyBuilderPrivate

{

public:

    QMetaPropertyBuilderPrivate

            (const QByteArray& _name, const QByteArray& _type, int notifierIdx=-1)

        : name(_name),

          type(QMetaObject::normalizedType(_type.constData())),

    {

        if (notifierIdx >= 0) {

            flags |= Notify;

            notifySignal = notifierIdx;

        }

    }

    QByteArray name;

    QByteArray type;

    int flags;

    int notifySignal;

    bool flag(int f) const

    {

        return ((flags & f) != 0);

    }

    void setFlag(int f, bool value)

    {

        if (value)

            flags |= f;

        else

            flags &= ~f;

    }

};

class QMetaEnumBuilderPrivate

{

public:

    QMetaEnumBuilderPrivate(const QByteArray& _name)

        : name(_name), isFlag(false)

    {

    }

    QByteArray name;

    bool isFlag;

    QList<QByteArray> keys;

    QList<int> values;

};

class QMetaObjectBuilderPrivate

{

public:

    QMetaObjectBuilderPrivate()

        : flags(0)

    {

        superClass = &QObject::staticMetaObject;

        staticMetacallFunction = 0;

    }

    QByteArray className;

    const QMetaObject *superClass;

    QMetaObjectBuilder::StaticMetacallFunction staticMetacallFunction;

    QList<QMetaMethodBuilderPrivate> methods;

    QList<QMetaMethodBuilderPrivate> constructors;

    QList<QMetaPropertyBuilderPrivate> properties;

    QList<QByteArray> classInfoNames;

    QList<QByteArray> classInfoValues;

    QList<QMetaEnumBuilderPrivate> enumerators;

#ifdef Q_NO_DATA_RELOCATION

    QList<QMetaObjectAccessor> relatedMetaObjects;

#else

    QList<const QMetaObject *> relatedMetaObjects;

#endif

    int flags;

};

/*!

    Constructs a new QMetaObjectBuilder.

*/

QMetaObjectBuilder::QMetaObjectBuilder()

{

    d = new QMetaObjectBuilderPrivate();

}

/*!

    Constructs a new QMetaObjectBuilder which is a copy of the

    meta object information in \a prototype.  Note: the super class

    contents for \a prototype are not copied, only the immediate

    class that is defined by \a prototype.

    The \a members parameter indicates which members of \a prototype

    should be added.  The default is AllMembers.

    \sa addMetaObject()

*/

QMetaObjectBuilder::QMetaObjectBuilder

    (const QMetaObject *prototype, QMetaObjectBuilder::AddMembers members)

{

    d = new QMetaObjectBuilderPrivate();

    addMetaObject(prototype, members);

}

/*!

    Destroys this meta object builder.

*/

QMetaObjectBuilder::~QMetaObjectBuilder()

{

    delete d;

}

/*!

    Returns the name of the class being constructed by this

    meta object builder.  The default value is an empty QByteArray.

    \sa setClassName(), superClass()

*/

QByteArray QMetaObjectBuilder::className() const

{

    return d->className;

}

/*!

    Sets the \a name of the class being constructed by this

    meta object builder.

    \sa className(), setSuperClass()

*/

void QMetaObjectBuilder::setClassName(const QByteArray& name)

{

    d->className = name;

}

/*!

    Returns the superclass meta object of the class being constructed

    by this meta object builder.  The default value is the meta object

    for QObject.

    \sa setSuperClass(), className()

*/

const QMetaObject *QMetaObjectBuilder::superClass() const

{

    return d->superClass;

}

/*!

    Sets the superclass meta object of the class being constructed

    by this meta object builder to \a meta.  The \a meta parameter

    must not be null.

    \sa superClass(), setClassName()

*/

void QMetaObjectBuilder::setSuperClass(const QMetaObject *meta)

{

    Q_ASSERT(meta);

    d->superClass = meta;

}

/*!

    Returns the flags of the class being constructed by this meta object

    builder.

    \sa setFlags()

*/

QMetaObjectBuilder::MetaObjectFlags QMetaObjectBuilder::flags() const

{

    return (QMetaObjectBuilder::MetaObjectFlags)d->flags;

}

/*!

    Sets the \a flags of the class being constructed by this meta object

    builder.

    \sa flags()

*/

void QMetaObjectBuilder::setFlags(MetaObjectFlags flags)

{

    d->flags = flags;

}

/*!

    Returns the number of methods in this class, excluding the number

    of methods in the base class.  These include signals and slots

    as well as normal member functions.

    \sa addMethod(), method(), removeMethod(), indexOfMethod()

*/

int QMetaObjectBuilder::methodCount() const

{

    return d->methods.size();

}

/*!

    Returns the number of constructors in this class.

    \sa addConstructor(), constructor(), removeConstructor(), indexOfConstructor()

*/

int QMetaObjectBuilder::constructorCount() const

{

    return d->constructors.size();

}

/*!

    Returns the number of properties in this class, excluding the number

    of properties in the base class.

    \sa addProperty(), property(), removeProperty(), indexOfProperty()

*/

int QMetaObjectBuilder::propertyCount() const

{

    return d->properties.size();

}

/*!

    Returns the number of enumerators in this class, excluding the

    number of enumerators in the base class.

    \sa addEnumerator(), enumerator(), removeEnumerator()

    \sa indexOfEnumerator()

*/

int QMetaObjectBuilder::enumeratorCount() const

{

    return d->enumerators.size();

}

/*!

    Returns the number of items of class information in this class,

    exclusing the number of items of class information in the base class.

    \sa addClassInfo(), classInfoName(), classInfoValue(), removeClassInfo()

    \sa indexOfClassInfo()

*/

int QMetaObjectBuilder::classInfoCount() const

{

    return d->classInfoNames.size();

}

/*!

    Returns the number of related meta objects that are associated

    with this class.

    Related meta objects are used when resolving the enumerated type

    associated with a property, where the enumerated type is in a

    different class from the property.

    \sa addRelatedMetaObject(), relatedMetaObject()

    \sa removeRelatedMetaObject()

*/

int QMetaObjectBuilder::relatedMetaObjectCount() const

{

    return d->relatedMetaObjects.size();

}

/*!

    Adds a new public method to this class with the specified \a signature.

    Returns an object that can be used to adjust the other attributes

    of the method.  The \a signature will be normalized before it is

    added to the class.

    \sa method(), methodCount(), removeMethod(), indexOfMethod()

*/

QMetaMethodBuilder QMetaObjectBuilder::addMethod(const QByteArray& signature)

{

    int index = d->methods.size();

    d->methods.append(QMetaMethodBuilderPrivate(QMetaMethod::Method, signature));

    return QMetaMethodBuilder(this, index);

}

/*!

    Adds a new public method to this class with the specified

    \a signature and \a returnType.  Returns an object that can be

    used to adjust the other attributes of the method.  The \a signature

    and \a returnType will be normalized before they are added to

    the class.  If \a returnType is empty, then it indicates that

    the method has \c{void} as its return type.

    \sa method(), methodCount(), removeMethod(), indexOfMethod()

*/

QMetaMethodBuilder QMetaObjectBuilder::addMethod

    (const QByteArray& signature, const QByteArray& returnType)

{

    int index = d->methods.size();

    d->methods.append(QMetaMethodBuilderPrivate

        (QMetaMethod::Method, signature, returnType));

    return QMetaMethodBuilder(this, index);

}

/*!

    Adds a new public method to this class that has the same information as

    \a prototype.  This is used to clone the methods of an existing

    QMetaObject.  Returns an object that can be used to adjust the

    attributes of the method.

    This function will detect if \a prototype is an ordinary method,

    signal, slot, or constructor and act accordingly.

    \sa method(), methodCount(), removeMethod(), indexOfMethod()

*/

QMetaMethodBuilder QMetaObjectBuilder::addMethod(const QMetaMethod& prototype)

{

    QMetaMethodBuilder method;

    if (prototype.methodType() == QMetaMethod::Method)

        method = addMethod(prototype.signature());

    else if (prototype.methodType() == QMetaMethod::Signal)

        method = addSignal(prototype.signature());

    else if (prototype.methodType() == QMetaMethod::Slot)

        method = addSlot(prototype.signature());

    else if (prototype.methodType() == QMetaMethod::Constructor)

        method = addConstructor(prototype.signature());

    method.setReturnType(prototype.typeName());

    method.setParameterNames(prototype.parameterNames());

    method.setTag(prototype.tag());

    method.setAccess(prototype.access());

    method.setAttributes(prototype.attributes());

    return method;

}

/*!

    Adds a new public slot to this class with the specified \a signature.

    Returns an object that can be used to adjust the other attributes

    of the slot.  The \a signature will be normalized before it is

    added to the class.

    \sa addMethod(), addSignal(), indexOfSlot()

*/

QMetaMethodBuilder QMetaObjectBuilder::addSlot(const QByteArray& signature)

{

    int index = d->methods.size();

    d->methods.append(QMetaMethodBuilderPrivate(QMetaMethod::Slot, signature));

    return QMetaMethodBuilder(this, index);