/****************************************************************************
**
** Copyright (C) 2017 Ford Motor Company
** Contact: https://www.qt.io/licensing/
**
** This file is part of the documentation of the Qt Toolkit.
**
** $QT_BEGIN_LICENSE:FDL$
** Commercial License Usage
** Licensees holding valid commercial Qt licenses may use this file in
** accordance with the commercial license agreement provided with the
** Software or, alternatively, in accordance with the terms contained in
** a written agreement between you and The Qt Company. For licensing terms
** and conditions see https://www.qt.io/terms-conditions. For further
** information use the contact form at https://www.qt.io/contact-us.
**
** GNU Free Documentation License Usage
** Alternatively, this file may be used under the terms of the GNU Free
** Documentation License version 1.3 as published by the Free Software
** Foundation and appearing in the file included in the packaging of
** this file. Please review the following information to ensure
** the GNU Free Documentation License version 1.3 requirements
** will be met: https://www.gnu.org/licenses/fdl-1.3.html.
** $QT_END_LICENSE$
**
****************************************************************************/

/*!
\page qtremoteobjects-index.html
\title Qt Remote Objects
\ingroup overviews
\brief Provides APIs for inter-process communication using Qt Remote Objects

\target Qt Remote Objects
\section1 Remote Object Concepts

Qt Remote Objects (QtRO) is an inter-process communication (IPC) module
developed for Qt. The idea is to extend Qt's existing functionalities to enable
an easy exchange of information between processes or computers.

One of the key features of Qt to enable this is the distinction between an
object's API (defined by its properties, signals and slots) and the
implementation of that API. The purpose of QtRO is to meet the expected API, even
if the true QObject is in a different process. A slot called on a copy of an
object (called a \l {Replica} in QtRO) is forwarded to the true object (called
a \l {Source} in QtRO) for handling. Updates to the \l {Source} (either
property changes or emitted signals) are forwarded to every \l {Replica}.

A \l {Replica} is a light-weight proxy for the \l {Source} object, but one that
supports the same connections and behavior of QObjects, which makes it as
easy to use as any other QObject provided by Qt. Everything needed for the \l
{Replica} to look like the \l {Source} object is handled behind the scenes by
QtRO.

Note that Remote Objects behave differently from traditional remote procedure
call (RPC) implementations. In RPC, the client makes a request and waits for
the response. In RPC, the server does not push anything to the client unless it
is in response to a request. The design of RPC is often such that different
clients are independent of each other (for instance, two clients can ask a
mapping service for directions and get different results). While it is possible
to implement this in QtRO (as \l {Source} without properties, and slots that
have return values), it is designed more to hide the fact that the processing
is really remote. You let a node give you the \l {Replica} instead of creating
it yourself, possibly use the status signals (\l {QRemoteObjectReplica::} {isReplicaValid()}),
but then interact with the object like you would with any other QObject-based type.

\section1 Related Information

\section2 Getting Started

To enable \e {Qt Remote Objects} in a project, add this directive into
the C++ files:

\code
#include <QtRemoteObjects>
\endcode

To link against the \e {Qt Remote Objects} module, add this line to the project file:
\code
QT += remoteobjects
\endcode

\section2 Licenses

Qt Remote Objects is available under commercial licenses from \l{The Qt Company}.
In addition, it is available under the
\l{GNU Lesser General Public License, version 3}, or the
\l{GNU General Public License, version 2}.
See \l{Qt Licensing} for further details.

\section2 Guides
 \list
    \li \l {Overview Qt Remote Objects}
    \li \l {Qt Remote Objects C++ Classes}
    \li \l {Qt Remote Objects Nodes}
    \li \l {Source Objects}{Qt Remote Objects Source Objects}
    \li \l {Replica Objects}{Qt Remote Objects Replica Objects}
    \li \l {Qt Remote Objects Registry}
    \li \l {Qt Remote Objects - External QIODevices}
    \li \l {Qt Remote Objects Compiler}
    \li \l {Remote Object Interaction}
    \li \l {Using Qt Remote Objects}
    \li \l {Troubleshooting Qt Remote Objects}

 \endlist

\section2 Reference

\l {Qt Remote Objects C++ Classes}
\l {Qt Remote Objects QML Types}

*/