/*

* 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"

/*!

    \file xqserviceipcmarshal.h

*/

/*!

    \def Q_DECLARE_USER_METATYPE_NO_OPERATORS(TYPE)

    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 TYPE. A corresponding invocation of

    Q_IMPLEMENT_USER_METATYPE_NO_OPERATORS(TYPE) should appear in

    a source file. This macro should be used instead of

    Q_DECLARE_USER_METATYPE when no need to declare datastream operators.

    This example declares the class MyClass that doesn't need to declare

    datastream operators:

    \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()

*/

/*!

    \def Q_DECLARE_USER_METATYPE(TYPE)

    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()

*/

/*!

    \def Q_DECLARE_USER_METATYPE_TYPEDEF(TAG,TYPE)

    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()

*/

/*!

    \def Q_IMPLEMENT_USER_METATYPE_NO_OPERATORS(TYPE)

    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 MyClass that

    doesn't need to declare datastream operators:

    \code

        Q_IMPLEMENT_USER_METATYPE_NO_OPERATORS(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_IMPLEMENT_USER_METATYPE_ENUM(), Q_IMPLEMENT_USER_METATYPE(), Q_DECLARE_METATYPE(), Q_REGISTER_USER_METATYPE()

*/

/*!

    \def Q_DECLARE_USER_METATYPE_ENUM(TYPE)

    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()

*/

/*!

    \def Q_IMPLEMENT_USER_METATYPE(TYPE)

    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()

*/

/*!

    \def Q_IMPLEMENT_USER_METATYPE_TYPEDEF(TAG,TYPE)

    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()

*/

/*!

    \def Q_IMPLEMENT_USER_METATYPE_ENUM(TYPE)

    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()

*/

/*!

    \def Q_REGISTER_USER_METATYPE(TYPE)

    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)