socket.hpp

Go to the documentation of this file.

/*
 * This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/.
 *
 * This file is part of zmqpp.
 * Copyright (c) 2011-2015 Contributors as noted in the AUTHORS file.
 */

#ifndef ZMQPP_SOCKET_HPP_
#define ZMQPP_SOCKET_HPP_

#include <cstring>
#include <string>
#include <list>

#include <zmq.h>

#include "compatibility.hpp"

#include "socket_mechanisms.hpp"
#include "socket_types.hpp"
#include "socket_options.hpp"
#include "signal.hpp"

namespace zmqpp
{

class context;
class message;

typedef std::string endpoint_t;
typedef context     context_t;
typedef message     message_t;

#if (ZMQ_VERSION_MAJOR >= 4)
namespace event
{
    const int connected        = ZMQ_EVENT_CONNECTED;       /*<! connection established */
    const int connect_delayed  = ZMQ_EVENT_CONNECT_DELAYED; /*<! synchronous connect failed, it's being polled */
    const int connect_retried  = ZMQ_EVENT_CONNECT_RETRIED; /*<! asynchronous connect / reconnection attempt */
    const int listening        = ZMQ_EVENT_LISTENING;       /*<! socket bound to an address, ready to accept connections */
    const int bind_failed      = ZMQ_EVENT_BIND_FAILED;     /*<! socket could not bind to an address */
    const int accepted         = ZMQ_EVENT_ACCEPTED;        /*<! connection accepted to bound interface */
    const int accept_failed    = ZMQ_EVENT_ACCEPT_FAILED;   /*<! could not accept client connection */
    const int closed           = ZMQ_EVENT_CLOSED;          /*<! connection closed */
    const int close_failed     = ZMQ_EVENT_CLOSE_FAILED;    /*<! connection couldn't be closed */
    const int disconnected     = ZMQ_EVENT_DISCONNECTED;    /*<! broken session */

    const int all              = ZMQ_EVENT_ALL;             /*<! all event flags */
}
#endif

class socket
{
public:
    static const int normal;                    
#if (ZMQ_VERSION_MAJOR == 2)
    static const int dont_wait;                 
#else
    static const int dont_wait;                 
#endif
    static const int send_more;                 
#ifdef ZMQ_EXPERIMENTAL_LABELS
    static const int send_label;                
#endif

    socket(context_t const& context, socket_type const type);

    ~socket();

    socket_type type() const { return _type; }

    void bind(endpoint_t const& endpoint);

#if (ZMQ_VERSION_MAJOR > 3) || ((ZMQ_VERSION_MAJOR == 3) && (ZMQ_VERSION_MINOR >= 2))

    void unbind(endpoint_t const& endpoint);
#endif

    void connect(endpoint_t const& endpoint);

    template<typename InputIterator>
    void connect(InputIterator const& connections_begin, InputIterator const& connections_end)
    {
        for(InputIterator it = connections_begin; it != connections_end; ++it)
        {
            connect(*it);
        }
    }


#if (ZMQ_VERSION_MAJOR > 3) || ((ZMQ_VERSION_MAJOR == 3) && (ZMQ_VERSION_MINOR >= 2))
    void disconnect(endpoint_t const& endpoint);

    template<typename InputIterator>
    void disconnect(InputIterator const& disconnections_begin, InputIterator const& disconnections_end)
    {
        for(InputIterator it = disconnections_begin; it != disconnections_end; ++it)
        {
            disconnect(*it);
        }
    }
#endif

    void close();

    bool send(message_t& message, bool const dont_block = false);

    bool receive(message_t& message, bool const dont_block = false);

    bool send(std::string const& string, int const flags = normal);

    bool receive(std::string& string, int const flags = normal);

    bool send(signal sig, bool dont_block = false);


    bool receive(signal &sig, bool dont_block = false);

    bool send_raw(char const* buffer, size_t const length, int const flags = normal);

    bool receive_raw(char* buffer, size_t& length, int const flags = normal);

    void subscribe(std::string const& topic);

    template<typename InputIterator>
    void subscribe(InputIterator const& topics_begin, InputIterator const& topics_end)
    {
        for(InputIterator it = topics_begin; it != topics_end; ++it)
        {
            subscribe(*it);
        }
    }

    void unsubscribe(std::string const& topic);

    template<typename InputIterator>
    void unsubscribe(InputIterator const& topics_begin, InputIterator const& topics_end)
    {
        for(InputIterator it = topics_begin; it != topics_end; ++it)
        {
            unsubscribe(*it);
        }
    }

    bool has_more_parts() const;

    void set(socket_option const option, int const value);

    void set(socket_option const option, bool const value);

    void set(socket_option const option, uint64_t const value);

    void set(socket_option const option, int64_t const value);

    void set(socket_option const option, char const* value, size_t const length);

    inline void set(socket_option const option, char const* value) { set(option, value, strlen(value)); }

    inline void set(socket_option const option, std::string const value) { set(option, value.c_str(), value.length()); }

    void get(socket_option const option, int& value) const;

    void get(socket_option const option, bool& value) const;

    void get(socket_option const option, uint64_t& value) const;

    void get(socket_option const option, int64_t& value) const;

    void get(socket_option const option, std::string& value) const;

    template<typename Type>
    Type get(socket_option const option) const
    {
        Type value = Type();
        get(option, value);
        return value;
    }

#if (ZMQ_VERSION_MAJOR >= 4)

    void monitor(endpoint_t const monitor_endpoint, int events_required);
#endif

    signal wait();

    socket(socket&& source) NOEXCEPT;

    socket& operator=(socket&& source) NOEXCEPT;

    operator bool() const;

    operator void*() const;

private:
    void* _socket;
    socket_type _type;
    zmq_msg_t _recv_buffer;

    // No copy
    socket(socket const&) NOEXCEPT ZMQPP_EXPLICITLY_DELETED;
    socket& operator=(socket const&) NOEXCEPT ZMQPP_EXPLICITLY_DELETED;

    void track_message(message_t const&, uint32_t const, bool&);
};

}

#endif /* ZMQPP_SOCKET_HPP_ */