--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/qthighway/xqservice/src/xqserviceipcmarshal.cpp Tue Aug 31 16:02:37 2010 +0300
@@ -0,0 +1,209 @@
+/*
+* 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)