/*
* 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)