lcm-cpp.hpp

#ifndef __lcm_cpp_hpp__
#define __lcm_cpp_hpp__
 
#ifndef LCM_CXX_11_ENABLED
#if __cplusplus >= 201103L
#define LCM_CXX_11_ENABLED 1
#else
#define LCM_CXX_11_ENABLED 0
#endif
#endif
 
#include <cstdio> /* needed for FILE* */
#include <string>
#include <vector>
 
#include "lcm.h"
 
#if LCM_CXX_11_ENABLED
#include <functional>
#endif
 
namespace lcm {
 
class Subscription;
 
struct ReceiveBuffer;
 
class LCM {
  public:
    inline LCM(std::string lcm_url = "");
 
    inline LCM(lcm_t *lcm_in);
 
    inline ~LCM();
 
    inline bool good() const;
 
    inline int publish(const std::string &channel, const void *data, unsigned int datalen);
 
    template <class MessageType>
    inline int publish(const std::string &channel, const MessageType *msg);
 
    inline int getFileno();
 
    inline int handle();
 
    inline int handleTimeout(int timeout_millis);
 
    template <class MessageType, class MessageHandlerClass>
    Subscription *subscribe(const std::string &channel,
                            void (MessageHandlerClass::*handlerMethod)(const ReceiveBuffer *rbuf,
                                                                       const std::string &channel,
                                                                       const MessageType *msg),
                            MessageHandlerClass *handler);
 
    template <class MessageHandlerClass>
    Subscription *subscribe(const std::string &channel,
                            void (MessageHandlerClass::*handlerMethod)(const ReceiveBuffer *rbuf,
                                                                       const std::string &channel),
                            MessageHandlerClass *handler);
 
    template <class MessageType, class ContextClass>
    Subscription *subscribeFunction(const std::string &channel,
                                    void (*handler)(const ReceiveBuffer *rbuf,
                                                    const std::string &channel,
                                                    const MessageType *msg, ContextClass context),
                                    ContextClass context);
 
    template <class ContextClass>
    Subscription *subscribeFunction(const std::string &channel,
                                    void (*handler)(const ReceiveBuffer *rbuf,
                                                    const std::string &channel,
                                                    ContextClass context),
                                    ContextClass context);
 
#if LCM_CXX_11_ENABLED
    template <class MessageType>
    using HandlerFunction = std::function<void(const ReceiveBuffer *rbuf,
                                               const std::string &channel, const MessageType *msg)>;
    template <class MessageType>
    Subscription *subscribe(const std::string &channel, HandlerFunction<MessageType> handler);
#endif
 
    inline int unsubscribe(Subscription *subscription);
 
    inline lcm_t *getUnderlyingLCM();
 
  private:
    lcm_t *lcm;
    bool owns_lcm;
 
    std::vector<Subscription *> subscriptions;
};
 
struct ReceiveBuffer {
    void *data;
    uint32_t data_size;
    int64_t recv_utime;
};
 
class Subscription {
  public:
    virtual ~Subscription() {}
    inline int setQueueCapacity(int num_messages);
 
    inline int getQueueSize() const;
 
    friend class LCM;
 
  protected:
    Subscription() { channel_buf.reserve(LCM_MAX_CHANNEL_NAME_LENGTH); };
 
    lcm_subscription_t *c_subs;
 
    // A "workspace" string that is overwritten with the channel name during
    // message handling. This string serves to eliminate a heap allocation that
    // would otherwise occur and which could preclude use in real-time
    // applications.
    std::string channel_buf;
};
 
struct LogEvent {
    int64_t eventnum;
    int64_t timestamp;
    std::string channel;
    int32_t datalen;
    void *data;
};
 
class LogFile {
  public:
    inline LogFile(const std::string &path, const std::string &mode);
 
    inline ~LogFile();
 
    inline bool good() const;
 
    inline const LogEvent *readNextEvent();
 
    inline int seekToTimestamp(int64_t timestamp);
 
    inline int writeEvent(LogEvent *event);
 
    inline FILE *getFilePtr();
 
  private:
    LogEvent curEvent;
    lcm_eventlog_t *eventlog;
    lcm_eventlog_event_t *last_event;
};
 
#define __lcm_cpp_impl_ok__
#include "lcm-cpp-impl.hpp"
#undef __lcm_cpp_impl_ok__
}  // namespace lcm
 
#endif