/*
* 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"
/*!
\macro 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()
*/
/*!
\macro 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.
s
\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()
*/
/*!
\macro 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()
*/
/*!
\macro 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()
*/
/*!
\macro 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()
*/
/*!
\macro 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()
*/
/*!
\macro 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)