/**
\page dependencies YARP Dependencies

\tableofcontents

\section dependencies_required Required Dependencies

YARP does not have any strong build dependencies, the only requirements
are
<a href="http://www.stroustrup.com/compilers.html"> a C++ compiler </a>
and CMake. We assume you have already installed them in your system.

Compilation instructions for YARP are reported here: \ref install.
This page reports instructions for compiling the dependencies in case you do not want to use precompiled libraries.

\subsection dependencies_ace The ACE Library

<a href="https://www.dre.vanderbilt.edu/~schmidt/ACE.html"><b>ACE</b></a>
is a free and open source library that provides an excellent portable
interface to a vast array of operating systems, dealing with the details
so you don't have to.

ACE is required on all the platforms except for Linux. Without ACE,
YARP will be able to connect using TCP only, and will have limited
functionality.

\subsubsection dependencies_ace_install The general approach to installing ACE

\li For Ubuntu and other deb-based systems, we suggest you install the
    \c libace-dev package (on rpm-based systems, try libace-devel).
    \verbatim
    sudo apt-get install libace-dev
    \endverbatim
\li For Windows and other systems we suggest the latest stable release
    (ACE-N.N.zip/ACE-N.N.tar.gz).  Download ACE
    <a href="https://download.dre.vanderbilt.edu/">here</a>.

Compile ACE using our summary instructions, below, or through the
official method given
<a href="https://htmlpreview.github.io/?https://github.com/DOCGroup/ACE_TAO/blob/master/ACE/ACE-INSTALL.html">here</a>.
Don't panic! The instructions cover a lot of operating systems and
compilers. Just look carefully for your combination.

\li Windows/DevStudio instructions are
    <a href="https://htmlpreview.github.io/?https://github.com/DOCGroup/ACE_TAO/blob/master/ACE/ACE-INSTALL.html#msvc">here </a>.
\li UNIX/gcc instructions are
    <a href="https://htmlpreview.github.io/?https://github.com/DOCGroup/ACE_TAO/blob/master/ACE/ACE-INSTALL.html#unix_traditional">here</a>.
\li macOS/gcc users, follow the UNIX instructions.

ACE will take a while to compile, but if you can do it you'll be able to
deal with anything we throw at you.

\subsubsection dependencies_ace_install_unix Compiling ACE on UNIX

If you are on a system with a binary ACE package (Debian, Redhat,
... -- it is usually called \c libace-dev or \c libace-devel), then you
can just install that and you are done. Otherwise you need to download
\c ACE-5.5.tar.gz as described above and follow these steps:

\li Let's suppose you have placed \c ACE-5.5.tar.gz in the directory
    \c $HOME/work/. Then, in this directory, type:
    \verbatim
    tar xzvf - < ACE-5.5.tar.gz
    \endverbatim
\li You should now have a subdirectory called "ACE_wrappers". Type one
    (or if you're not sure which, type both) of:
    \verbatim
    export ACE_ROOT=$PWD/ACE_wrappers
    setenv ACE_ROOT $PWD/ACE_wrappers
    \endverbatim
\li One of these lines will succeed and the other will fail, depending
    on what shell you use. That's fine. as long as when you type:
    \<tt>echo $ACE_ROOT</tt> you get the \c ACE_wrappers directory.
\li You now need to configure ACE to your platform, by creating one
    build file and one include file. If you are on Linux, type:
    \verbatim
    cd $ACE_ROOT/include/makeinclude/
    ln -s platform_linux.GNU platform_macros.GNU
    cd $ACE_ROOT/ace
    ln -s config-linux.h config.h
    \endverbatim
\li If you are not on Linux, or even if you are, you should take a look
    at the \c platform_*.GNU and \c config-*.h files and pick the one
    that matches you.
\li Now, to compile, type:
    \verbatim
    cd $ACE_ROOT/ace; make
    \endverbatim
\li If all goes well, at the end you will have some files in
    \c ACE_wrappers/ace, for example:
    \verbatim
    $ ls $ACE_ROOT/lib/
    libACE.so  libACE.so.5.4.7
    \endverbatim
    (the \c .so may be \c .dylib or other variants):
\li One thing remains to be done; programs need to be able to find the
    ACE library at run time. You can set this up by running one of the
    following:
    \verbatim
    export LD_LIBRARY_PATH=$ACE_ROOT/lib:$LD_LIBRARY_PATH
    setenv LD_LIBRARY_PATH $ACE_ROOT/lib:$LD_LIBRARY_PATH
    \endverbatim
\li (On macOS, the variable you need to set is \c DYLD_LIBRARY_PATH).
\li An alternative is to copy the files in \c $ACE_ROOT/lib to a
    standard library directory, for example, \c /usr/lib.
\li We've given a simple procedure that works for most people. But if
    you run into a lot of trouble, we suggest you delete the
    \c ACE_wrappers directory, recreate it with tar again as above, and
    follow carefully all the detailed instructions
    <a href="https://htmlpreview.github.io/?https://github.com/DOCGroup/ACE_TAO/blob/master/ACE/ACE-INSTALL.html#unix_traditional">here</a>.


\subsubsection ace_windows Compiling ACE on Windows

For Borland C++Builder, MinGW, Cygwin instructions build instructions
are
<a href="https://htmlpreview.github.io/?https://github.com/DOCGroup/ACE_TAO/blob/master/ACE/ACE-INSTALL.html#win32">here</a>.

For Visual Studio, here's a brief summary of the steps.
\li Get \c ACE-5.5.zip as described above.
\li Unpack its contents to a directory. Find the directory
    \c ACE_wrappers in the unpacked material.
\li In the \c ACE_wrappers\ace directory, create a file called
    \c config.h and edit it to be just this:
    \code{.h}
    #include "ace/config-win32.h"
    \endcode
\li Open Visual Studio. Go to open a project/workspace/solution, and
    browse to the directory \c ACE_wrappers\ace.
\li Find the project/workspace/solution that works for you: probably
    called \c ACE.dsw or \c ace_vc8.sln.
\li Compile! We suggest you compile both debug and release versions of
    the library.
\li On Visual Studio Express, you may need to add the in project
    properties -> linker -> input -> additional dependencies:
    \c kernel32.lib, \c user32.lib, \c advapi32.lib.
    See also
    <a href="http://msdn.microsoft.com/vstudio/express/visualc/usingsdk/">here (FIXME broken)</a>
\li In the end, you should have some files in the directory
    \c ACE_wrappers/lib, including \c ACE.dll, \c ACE.lib, \c ACEd.dll,
    \c ACEd.lib (if you compiled both release and debug versions).
\li You must make sure you include the path to \c ACE_wrappers\lib in
    your \c PATH environment variable whenever you run programs that
    uses ACE. See generic instructions for setting environment
    variables
    <a href="http://www.microsoft.com/resources/documentation/windows/xp/all/proddocs/en-us/environment_variables.mspx">here</a>.
\li It is also a good idea to set an environment variable \c ACE_ROOT to
    hold the path to \c ACE_wrappers. This will make it easier to find
    the libraries and header files.

On Windows you can unzip the ACE distribution and simply open the
workspace file contained within it from within Visual Studio and
then start the compilation.  We recommend you compile twice,
once in debug mode and release mode, so you have both versions of
the library available later.

\subsection dependencies_eigen Eigen

<a href="http://eigen.tuxfamily.org"><b>Eigen</b></a> is a C++ template header only
library for linear algebra: matrices, vectors, numerical solvers, and related algorithms.

If not installed, you will not be able to enable the \c YARP_math library.

\subsubsection dependencies_eigen_linux Linux
The most convenient way of installing Eigen in recent Linux distribution is using the
system package manager.
For example in Debian/Ubuntu you can install the `libeigen3-dev` package by typing on a terminal:
~~~
sudo apt-get install libeigen3-dev
~~~

\subsubsection dependencies_eigen_macos macOS
The most convenient way of installing Eigen in macOS is using <a href="http://brew.sh">homebrew</a>.
If you have installed homebrew on your computer, you can install eigen by typing on a terminal:
~~~
brew install eigen
~~~

\subsubsection dependencies_eigen_windows Windows
The most convenient way of installing Eigen on Windows is by downloading the compressed archive of the
latest version of Eigen from the <a href="http://eigen.tuxfamily.org">Eigen website</a>.
As Eigen is an header only library, you can just unzip the archive in a directory,
and point the `EIGEN3_ROOT` environment variable to the directory in which
you uncompressed the archive. In particular `EIGEN3_ROOT` should point to the
directory containing the `signature_of_eigen3_matrix_library` file.

\section dependencies_gui GUI Dependencies

\subsection dependencies_qt5 Qt5 (Recommended)

Qt 5.2 or later is required. YARP GUIs use the QtQuick Controls module
that is available only since 5.2.

The recommended way to install Qt5 on your system is to use the binary
packages supplied by your distribution (if available). If they are not
available, you can download a binary release from the
<a href="http://qt-project.org/downloads">Qt Project website</a>, or
download the source code, and build it yourself.

If you installed Qt5 from the Qt Project website, you will also need
need to set up the environment variable \c Qt5_DIR pointing to the
location where Qt5 cmake modules are, e.g. for Qt 5.3 on Linux 64 bit:

\verbatim
export Qt5_DIR=/path/to/Qt/5.3/gcc_64/lib/cmake/Qt5/
\endverbatim

Alternatively you can add the install path to the CMAKE_PREFIX_PATH
environment variable, for example:

\verbatim
export CMAKE_PREFIX_PATH=$CMAKE_PREFIX_PATH:/path/to/Qt/5.3/gcc_64/
\endverbatim

\subsubsection dependencies_qt5_Linux Linux




\paragraph dependencies_qt5_debian_ubuntu Debian/Ubuntu


On Debian and Ubuntu systems, you need to install the following packages:

\li qtbase5-dev
\li qtdeclarative5-dev
\li qtmultimedia5-dev
\li qml-module-qtquick2
\li qml-module-qtquick-window2
\li qml-module-qtmultimedia
\li qml-module-qtquick-dialogs
\li qml-module-qtquick-controls

You can install them by running:

\verbatim
sudo apt-get install qtbase5-dev qtdeclarative5-dev qtmultimedia5-dev \
  qml-module-qtquick2 qml-module-qtquick-window2 \
  qml-module-qtmultimedia qml-module-qtquick-dialogs \
  qml-module-qtquick-controls
\endverbatim


\paragraph dependencies_qt5_linux_others Others
If your distribution does not supply binary packages for Qt5, you can
download a binary release from the
<a href="http://qt-project.org/downloads">Qt Project website</a>, or
download the source code, and build it yourself.


\subsubsection dependencies_qt5_windows Windows

Qt5 binary package for Windows is available from the
<a href="http://qt-project.org/downloads">Qt Project website</a>

\subsubsection dependencies_qt5_macos macOS

Qt5 binary package for Mac is available from the
<a href="http://qt-project.org/downloads">Qt Project website</a>

*/
