diff -r 885c2596c964 -r 5d007b20cfd0 qthighway/xqservice/src/xqserviceipcmarshal.cpp
--- /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)