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

\target Qt Remote Objects
\section1 Remote Object Concepts

Qt Remote Objects (QtRO) is an Inter-Process Communication (IPC) module
developed for Qt. This module extends Qt's existing functionalities to enable
information exchange between processes or computers, easily.

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

A \l {Replica} is a light-weight proxy for the \l {Source} object, but a
Replica supports the same connections and behavior of QObjects, which makes it
usable in the same way as any other QObject that Qt provides. Behind the
scenes, QtRO handles everything that's necessary for the Replica to look like
its Source.

Note that Remote Objects behave differently from traditional Remote Procedure
Call (RPC) implementations, for example:

\list
   \li In RPC, the client makes a request and waits for the response.
   \li In RPC, the server doesn't push anything to the client unless it's in
       response to a request.
   \li Often, the design of RPC is such that different clients are independent
       of each other: for instance, two clients can ask a mapping service for
       directions and get different results.
\endlist

While it is possible to implement this RPC-style behavior in QtRO, as Sources
without properties, and slots that have return values, QtRO hides the fact that
the processing is really remote. You let a node give you the 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 Get 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

\section1 Guides
 \list
    \li \l {Overview Qt Remote Objects}
    \li \l {Using Qt Remote Objects}
    \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 {Troubleshooting Qt Remote Objects}
    \li \l {Qt Remote Objects Protocol Versioning}
 \endlist

\section2 Reference

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

\section1 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.

*/
