/*

* Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

*

* This program 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, version 2.1 of the License.

* 

* 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 Lesser General Public License for more details.

*

* You should have received a copy of the GNU Lesser General Public License

* along with this program.  If not, 

* see "http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html/".

*

* Description:                                                         

*

*/

#include "xqserviceipcmarshal.h"

/*!

    This macro declares \a TYPE as a user-defined type within the

    Qt metatype system.  It should be used in header files, just

    after the declaration of \a TYPE.  A corresponding invocation

    of Q_IMPLEMENT_USER_METATYPE should appear in a source file.

    This example declares the class \c{MyClass}:

    \code

        Q_DECLARE_USER_METATYPE(MyClass)

    \endcode

    \sa Q_DECLARE_USER_METATYPE_ENUM(), Q_IMPLEMENT_USER_METATYPE(), Q_IMPLEMENT_USER_METATYPE_ENUM(), Q_REGISTER_USER_METATYPE()

*/

/*!

    This macro declares \a TYPE as a user-defined type within the

    Qt metatype system, but declares it as a typedef for a pre-existing

    metatype.  The \a TAG is an identifier that will usually be the same

    as \a TYPE, but may be slightly different if \a TYPE is nested.

    For example, if \a TYPE is \c{Foo::Bar}, then \a TAG should be

    \c{Foo_Bar} to make it a valid identifier.

    This macro should be used in header files, just after the declaration

    of \a TYPE.  A corresponding invocation of

    Q_IMPLEMENT_USER_METATYPE_TYPEDEF should appear in a source file.

    This example declares the types \c{Foo} and \c{Bar} as typedef aliases.

    \code

        typedef Foo Bar;

        Q_DECLARE_USER_METATYPE(Foo)

        Q_DECLARE_USER_METATYPE_TYPEDEF(Bar, Bar)

    \endcode

    \sa Q_DECLARE_USER_METATYPE_ENUM(), Q_IMPLEMENT_USER_METATYPE(), Q_IMPLEMENT_USER_METATYPE_ENUM(), Q_REGISTER_USER_METATYPE()

*/

/*!

    This macro declares \a TYPE as a user-defined enumerated type within

    the Qt metatype system.  It should be used in header files, just

    after the declaration of \a TYPE.  A corresponding invocation

    of Q_IMPLEMENT_USER_METATYPE_ENUM should appear in a source file.

    This example declares the enumerated type \c{MyEnum}:

    \code

        Q_DECLARE_USER_METATYPE_ENUM(MyEnum)

    \endcode

    This macro differs from Q_DECLARE_USER_METATYPE in that it explicitly

    declares datastream operators for the type.

    \sa Q_IMPLEMENT_USER_METATYPE_ENUM(), Q_IMPLEMENT_USER_METATYPE(), Q_DECLARE_METATYPE(), Q_REGISTER_USER_METATYPE()

*/

/*!

    This macro implements the code necessary to register \a TYPE

    as a user-defined type within the Qt metatype system.

    This example implements the registration logic for the class \c{MyClass}:

    \code

        Q_IMPLEMENT_USER_METATYPE(MyClass)

    \endcode

    On most systems, this macro will arrange for registration to be

    performed at program startup.  On systems that don't support

    global constructors properly, it may be necessary to manually

    call Q_REGISTER_USER_METATYPE().

    \sa Q_DECLARE_USER_METATYPE(), Q_DECLARE_USER_METATYPE_ENUM(), Q_IMPLEMENT_USER_METATYPE_ENUM(), Q_REGISTER_USER_METATYPE()

*/

/*!

    This macro implements the code necessary to register \a TYPE

    as a user-defined typedef alias within the Qt metatype system.

    The \a TAG should be the same as the tag used in the

    corresponding invocation of Q_DECLARE_USER_METATYPE_TYPEDEF.

    This example implements the registration logic for the typedef'ed

    types \c{Foo} and \c{Bar}:

    \code

        typedef Foo Bar;

        Q_IMPLEMENT_USER_METATYPE(Foo)

        Q_IMPLEMENT_USER_METATYPE_TYPEDEF(Bar, Bar)

    \endcode

    On most systems, this macro will arrange for registration to be

    performed at program startup.  On systems that don't support

    global constructors properly, it may be necessary to manually

    call Q_REGISTER_USER_METATYPE().

    \sa Q_DECLARE_USER_METATYPE(), Q_DECLARE_USER_METATYPE_ENUM(), Q_IMPLEMENT_USER_METATYPE_ENUM(), Q_REGISTER_USER_METATYPE()

*/

/*!

    This macro implements the code necessary to register \a TYPE

    as a user-defined type within the Qt metatype system.  \a TYPE

    is assumed to be an enumerated type.  Using this macro relieves

    the need to manually declare \c{operator<<} and \c{operator>>}

    for the enumerated type.  Non-enumerated types should use

    Q_IMPLEMENT_USER_METATYPE() instead.

    This example implements the registration logic for the type \c{MyEnum}:

    \code

        Q_IMPLEMENT_USER_METATYPE_ENUM(MyEnum)

    \endcode

    On most systems, this macro will arrange for registration to be

    performed at program startup.  On systems that don't support

    global constructors properly, it may be necessary to manually

    call Q_REGISTER_USER_METATYPE().

    \sa Q_DECLARE_USER_METATYPE_ENUM(), Q_DECLARE_USER_METATYPE(), Q_IMPLEMENT_USER_METATYPE(), Q_REGISTER_USER_METATYPE()

*/

/*!

    This macro can be called as a function to manually register \a TYPE

    as a user-defined type within the Qt metatype system.  It is only

    needed if the system does not support global constructors properly.

    \sa Q_DECLARE_USER_METATYPE(), Q_DECLARE_USER_METATYPE_ENUM(), Q_IMPLEMENT_USER_METATYPE(), Q_IMPLEMENT_USER_METATYPE_ENUM()

*/

Q_IMPLEMENT_USER_METATYPE_NO_OPERATORS(QUuid)