Network.h

Go to the documentation of this file.

/*
 * Copyright (C) 2006-2020 Istituto Italiano di Tecnologia (IIT)
 * Copyright (C) 2006-2010 RobotCub Consortium
 * All rights reserved.
 *
 * This software may be modified and distributed under the terms of the
 * BSD-3-Clause license. See the accompanying LICENSE file for details.
 */
 
#ifndef YARP_OS_NETWORK_H
#define YARP_OS_NETWORK_H
 
#include <yarp/os/Contact.h>
#include <yarp/os/ContactStyle.h>
#include <yarp/os/NameStore.h>
#include <yarp/os/Portable.h>
#include <yarp/os/Property.h>
#include <yarp/os/QosStyle.h>
#include <yarp/os/Time.h>
#include <yarp/os/Value.h>
 
 
namespace yarp {
namespace os {
class ContactStyle;
class QosStyle;
} // namespace os
} // namespace yarp
 
// Make plugins in a library available for use
#define YARP_DECLARE_PLUGINS(name) extern "C" void add_ ## name ## _plugins();
#define YARP_REGISTER_PLUGINS(name) add_ ## name ## _plugins();
 
namespace yarp {
namespace os {
 
class YARP_os_API NetworkBase
{
public:
    static void initMinimum();
 
    static void initMinimum(yarp::os::yarpClockType clockType,
                            yarp::os::Clock* custom = nullptr);
 
    static void autoInitMinimum();
 
    static void autoInitMinimum(yarp::os::yarpClockType clockType,
                                yarp::os::Clock* custom = nullptr);
 
    static void yarpClockInit(yarp::os::yarpClockType clockType,
                              Clock* custom = nullptr);
 
    static void finiMinimum();
 
    /*
     * Return true if network is initialized.
     * Expect problem if you use things that require a network before
     * initializing it.
     */
    static bool isNetworkInitialized();
 
    static bool connect(const std::string& src,
                        const std::string& dest,
                        const std::string& carrier = "",
                        bool quiet = true);
 
    // Catch old uses of nullptr for carrier
    static bool connect(const char* src,
                        const char* dest,
                        const char* carrier,
                        bool quiet = true)
    {
        return connect(std::string(src),
                       std::string(dest),
                       std::string((carrier == nullptr) ? "" : carrier),
                       quiet);
    }
 
    static bool connect(const std::string& src,
                        const std::string& dest,
                        const ContactStyle& style);
 
    static bool disconnect(const std::string& src,
                           const std::string& dest,
                           bool quiet);
 
    static bool disconnect(const std::string& src,
                           const std::string& dest,
                           const ContactStyle& style);
 
    static bool disconnect(const std::string& src,
                        const std::string& dest,
                        const std::string& carrier = "",
                        bool quiet = true);
 
    // Catch old uses of nullptr for carrier
    static bool disconnect(const char* src,
                        const char* dest,
                        const char* carrier,
                        bool quiet = true)
    {
        return disconnect(std::string(src),
                       std::string(dest),
                       std::string((carrier == nullptr) ? "" : carrier),
                       quiet);
    }
 
    static bool isConnected(const std::string& src,
                            const std::string& dest,
                            bool quiet);
 
    static bool isConnected(const std::string& src,
                            const std::string& dest,
                            const ContactStyle& style);
 
    static bool isConnected(const std::string& src,
                        const std::string& dest,
                        const std::string& carrier = "",
                        bool quiet = true);
 
    // Catch old uses of nullptr for carrier
    static bool isConnected(const char* src,
                        const char* dest,
                        const char* carrier,
                        bool quiet = true)
    {
        return isConnected(std::string(src),
                       std::string(dest),
                       std::string((carrier == nullptr) ? "" : carrier),
                       quiet);
    }
 
    static bool exists(const std::string& port,
                       bool quiet = true,
                       bool checkVer = true);
 
    static bool exists(const std::string& port,
                       const ContactStyle& style,
                       bool checkVer = true);
 
    static bool sync(const std::string& port,
                     bool quiet = true);
 
    static void assertion(bool shouldBeTrue);
 
    static Contact queryName(const std::string& name);
 
    static Contact registerName(const std::string& name);
 
    static Contact registerContact(const Contact& contact);
 
    static Contact unregisterName(const std::string& name);
 
    static Contact unregisterContact(const Contact& contact);
 
 
    static bool setProperty(const char* name,
                            const char* key,
                            const Value& value);
 
 
    static Value* getProperty(const char* name,
                              const char* key);
 
 
    static std::string getNameServerName();
 
    static Contact getNameServerContact();
 
 
    static bool setNameServerName(const std::string& name);
 
 
    static bool setLocalMode(bool flag);
 
    static bool getLocalMode();
 
#ifndef YARP_NO_DEPRECATED // Since YARP 3.0.0
    YARP_DEPRECATED
    static std::string readString(bool* eof = nullptr);
#endif // YARP_NO_DEPRECATED
 
 
    static bool write(const Contact& contact,
                      PortWriter& cmd,
                      PortReader& reply,
                      bool admin = false,
                      bool quiet = false,
                      double timeout = -1);
 
    static bool write(const Contact& contact,
                      PortWriter& cmd,
                      PortReader& reply,
                      const ContactStyle& style);
 
    static bool writeToNameServer(PortWriter& cmd,
                                  PortReader& reply,
                                  const ContactStyle& style);
 
    static bool write(const std::string& port_name,
                      PortWriter& cmd,
                      PortReader& reply);
 
 
    static bool checkNetwork();
 
 
    static bool checkNetwork(double timeout);
 
    static bool initialized();
 
#ifndef YARP_NO_DEPRECATED // Since YARP 3.4
    YARP_DEPRECATED_MSG("Use LogComponents instead")
    static void setVerbosity(int verbosity);
#endif // YARP_NO_DEPRECATED
 
    static void queryBypass(NameStore* store);
 
    static NameStore* getQueryBypass();
 
#ifndef YARP_NO_DEPRECATED // Since YARP 3.4
    YARP_DEPRECATED_MSG("Use yarp::conf::environment::getEnvironment instead")
    static std::string getEnvironment(const char* key,
                                      bool* found = nullptr);
 
    YARP_DEPRECATED_MSG("Use yarp::conf::environment::setEnvironment instead")
    static void setEnvironment(const std::string& key,
                               const std::string& val);
 
    YARP_DEPRECATED_MSG("Use yarp::conf::environment::unsetEnvironment instead")
    static void unsetEnvironment(const std::string& key);
#endif // YARP_NO_DEPRECATED
 
 
#ifndef YARP_NO_DEPRECATED // Since YARP 3.3.0
    YARP_DEPRECATED_MSG("Use yarp::conf::filesystem::preferred_separator instead")
    static std::string getDirectorySeparator();
 
    YARP_DEPRECATED_MSG("Use yarp::conf::filesystem::path_separator instead")
    static std::string getPathSeparator();
#endif // YARP_NO_DEPRECATED
 
    static bool registerCarrier(const char* name,
                                const char* dll);
 
    static void lock();
 
    static void unlock();
 
    static bool localNetworkAllocation();
 
    static Contact detectNameServer(bool useDetectedServer,
                                    bool& scanNeeded,
                                    bool& serverUsed);
 
    static bool setNameServerContact(Contact& nameServerContact);
 
    static std::string getConfigFile(const char* fname);
 
    static int getDefaultPortRange();
 
    static bool setConnectionQos(const std::string& src,
                                 const std::string& dest,
                                 const QosStyle& srcStyle,
                                 const QosStyle& destStyle,
                                 bool quiet = true);
 
    static bool setConnectionQos(const std::string& src,
                                 const std::string& dest,
                                 const QosStyle& style,
                                 bool quiet = true);
 
    static bool getConnectionQos(const std::string& src,
                                 const std::string& dest,
                                 QosStyle& srcStyle,
                                 QosStyle& destStyle,
                                 bool quiet = true);
 
    static bool isValidPortName(const std::string& portName);
 
    static bool waitConnection(const std::string& source,
                               const std::string& destination,
                               bool quiet = false);
 
    static bool waitPort(const std::string& target, bool quiet = false);
 
    static int sendMessage(const std::string& port,
                           yarp::os::PortWriter& writable,
                           bool silent = false);
 
    static int sendMessage(const std::string& port,
                           yarp::os::PortWriter& writable,
                           std::string& output,
                           bool quiet);
 
    static int disconnectInput(const std::string& src,
                               const std::string& dest,
                               bool silent = false);
 
    static int poll(const std::string& target, bool silent = false);
};
 
class YARP_init_API Network : public NetworkBase
{
public:
    Network();
 
    Network(yarp::os::yarpClockType clockType,
            yarp::os::Clock* custom = nullptr);
 
    virtual ~Network();
 
    static void init();
 
    static void init(yarp::os::yarpClockType clockType,
                     Clock* custom = nullptr);
 
    static void fini();
};
 
} // namespace os
} // namespace yarp
 
#endif // YARP_OS_NETWORK_H