peer.hpp

Go to the documentation of this file.

#ifndef ZIO_PEER_HPP_SEEN
#define ZIO_PEER_HPP_SEEN

#include <zyre.h>
#include <map>
#include <string>
#include <vector>

namespace zio {

    typedef std::string nickname_t;
    typedef std::string uuid_t;

    typedef std::string header_key_t;
    typedef std::string header_value_t;

    // header key must be unique in a header set
    typedef std::pair<header_key_t, header_value_t> header_t;
    typedef std::map<header_key_t, header_value_t> headerset_t;

    struct peer_info_t {
        nickname_t nick{""};
        headerset_t headers;

        // return a new mapping with entries of matching prefix.
        // Eg, {"a":"blech", "a.b":"foo", "a.b.c":"bar"}.
        // Branched on "a.b." returns: {c:"bar"}.
        // Branched on "a.b"  returns: {"":"foo", ".c":"bar"}
        headerset_t branch(const std::string& prefix);

    };

    typedef std::map<uuid_t, peer_info_t> peerset_t;

    class Peer {
    public:
        typedef int timeout_t;

        ~Peer();

        Peer(const nickname_t& nickname,
             const headerset_t& headers={}, bool verbose=false);


        void set_verbose(bool verbose=true);

        const nickname_t nickname() { return m_nick; }

        bool poll(timeout_t timeout = 0);

        void drain();

        std::vector<uuid_t> waitfor(const nickname_t& nickname,
                                    timeout_t timeout = -1);

        void waituntil(const uuid_t& uuid, timeout_t timeout = -1);

        const peerset_t& peers();

        peer_info_t peer_info(const uuid_t& uuid);

        bool isknown(const uuid_t& uuid);

        std::vector<uuid_t> nickmatch(const nickname_t& nick);

    private:
        std::string m_nick;
        bool m_verbose;
        zyre_t* m_zyre;

        peerset_t m_known_peers;
    };
}

#endif