servus.h

/* Copyright (c) 2012-2017, Human Brain Project
 *                          Stefan.Eilemann@epfl.ch
 *
 * This file is part of Servus <https://github.com/HBPVIS/Servus>
 *
 * This library is free software; you can redistribute it and/or modify it under
 * the terms of the GNU Lesser General Public License version 3.0 as published
 * by the Free Software Foundation.
 *
 * This library 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 library; if not, write to the Free Software Foundation, Inc.,
 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 */

#ifndef SERVUS_SERVUS_H
#define SERVUS_SERVUS_H

#include <servus/api.h>
#include <servus/result.h> // nested base class
#include <servus/types.h>

#include <map>
#include <memory>

namespace servus
{
static const std::string TEST_DRIVER{"_servus._test"};

class Servus
{
public:
    enum Interface
    {
        IF_ALL = 0, 
        // (uint32_t) -1 == kDNSServiceInterfaceIndexLocalOnly
        IF_LOCAL = (unsigned)(-1) 
    };

    class Result : public servus::Result
    {
    public:
        explicit Result(const int32_t code)
            : servus::Result(code)
        {
        }
        virtual ~Result() {}
        SERVUS_API std::string getString() const override;

        static const int32_t PENDING = -1;
        static const int32_t NOT_SUPPORTED = -2;
        static const int32_t POLL_ERROR = -3;
    };

    SERVUS_API static bool isAvailable();

    SERVUS_API explicit Servus(const std::string& name);

    SERVUS_API virtual ~Servus();

    SERVUS_API const std::string& getName() const;

    SERVUS_API void set(const std::string& key, const std::string& value);

    SERVUS_API Strings getKeys() const;

    SERVUS_API const std::string& get(const std::string& key) const;

    SERVUS_API Result announce(const unsigned short port,
                               const std::string& instance);

    SERVUS_API void withdraw();

    SERVUS_API bool isAnnounced() const;

    SERVUS_API Strings discover(const Interface addr,
                                const unsigned browseTime);

    SERVUS_API Result beginBrowsing(const servus::Servus::Interface addr);

    SERVUS_API Result browse(int32_t timeout = -1);

    SERVUS_API void endBrowsing();

    SERVUS_API bool isBrowsing() const;

    SERVUS_API Strings getInstances() const;

    SERVUS_API Strings getKeys(const std::string& instance) const;

    SERVUS_API const std::string& getHost(const std::string& instance) const;

    SERVUS_API bool containsKey(const std::string& instance,
                                const std::string& key) const;

    SERVUS_API const std::string& get(const std::string& instance,
                                      const std::string& key) const;

    SERVUS_API void addListener(Listener* listener);

    SERVUS_API void removeListener(Listener* listener);

    typedef std::map<std::string, std::map<std::string, std::string> > Data;

    SERVUS_API void getData(Data& data);

    class Impl; 

private:
    Servus(const Servus&) = delete;
    Servus& operator=(const Servus&) = delete;

    std::unique_ptr<Impl> _impl;

    friend SERVUS_API std::ostream& operator<<(std::ostream&, const Servus&);
};

SERVUS_API std::string getHostname();

SERVUS_API std::ostream& operator<<(std::ostream&, const Servus&);

SERVUS_API std::ostream& operator<<(std::ostream&, const Servus::Interface&);
}

#endif // SERVUS_SERVUS_H