ostream.h

Go to the documentation of this file.

#pragma once
#ifndef OSTREAM_H_
#define OSTREAM_H_

#include <stdarg.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include "ofxNetwork.h"
#include "stream.h"

const uint64_t kGracePeriod = 500; // 0.5 second

// Forward declaration.
class ofxTCPClient;

class OStream : public virtual Stream {
  public:
    virtual void onReceive(uint32_t label) = 0;
};

class OStreamVector : public OStream {
  public:
    virtual void onReceive(vector<double>) = 0;
};

class MacOSKeyboardOStream : public OStream {
  public:
    MacOSKeyboardOStream(std::map<uint32_t, char> key_mapping)
            : key_mapping_(key_mapping) {
    }

    MacOSKeyboardOStream(uint32_t count, ...) {
        va_list args;
        va_start(args, count);
        for (uint32_t i = 1; i <= count; i++) {
            key_mapping_[i] = va_arg(args, int);
        }
        va_end(args);
    }

    virtual void onReceive(uint32_t label) {
        if (has_started_) {
            if (getChar(label) != '\0') {
                sendKey(getChar(label));
            }
        }
    }

  private:
    void sendKey(char c);

    void sendString(const std::string& str);

    char getChar(uint32_t label) {
        return key_mapping_[label];
    }

    uint64_t elapsed_time_ = 0;
    std::map<uint32_t, char> key_mapping_;
};

class MacOSMouseOStream : public OStream {
  public:
    MacOSMouseOStream(std::map<uint32_t, pair<uint32_t, uint32_t> > mouse_mapping)
    : mouse_mapping_(mouse_mapping) {
    }

    MacOSMouseOStream(uint32_t count, ...) {
        va_list args;
        va_start(args, count);
        for (uint32_t i = 1; i <= count; i++) {
            mouse_mapping_[i] = make_pair(va_arg(args, uint32_t),
                                          va_arg(args, uint32_t));

        }
        va_end(args);
    }

    virtual void onReceive(uint32_t label) {
        if (has_started_) {
            pair<uint32_t, uint32_t> mouse = getMousePosition(label);
            if (mouse.first > 0 & mouse.second > 0) {
                clickMouse(mouse);
            }
        }
    }

private:
    void clickMouse(pair<uint32_t, uint32_t> mouse);
    void doubleClick(pair<uint32_t, uint32_t> mouse, int clickCount = 2);

    pair<uint32_t, uint32_t> getMousePosition(uint32_t label) {
        return mouse_mapping_[label];
    }

    uint64_t elapsed_time_ = 0;
    std::map<uint32_t, pair<uint32_t, uint32_t>> mouse_mapping_;
};

class TcpOStream : public OStreamVector {
  public:
    TcpOStream(string server, int port)
            : server_(server), port_(port),
              use_tcp_stream_mapping_(false), is_in_retry_(false) {}

    TcpOStream(string server, int port,
               std::map<uint32_t, string> tcp_stream_mapping)
            : server_(server), port_(port),
              use_tcp_stream_mapping_(true),
              tcp_stream_mapping_(tcp_stream_mapping),
              is_in_retry_(false) {
    }

    TcpOStream(string server, int port, uint32_t count, ...)
        : server_(server), port_(port), use_tcp_stream_mapping_(true),
          is_in_retry_(false) {
        va_list args;
        va_start(args, count);
        for (uint32_t i = 1; i <= count; i++) {
            char* s = va_arg(args, char *);
            tcp_stream_mapping_[i] = std::string(s);
        }
        va_end(args);
    }

    virtual void onReceive(uint32_t label) {
        if (has_started_) {
            string to_send = getStreamString(label);
            if (!to_send.empty()) {
                sendString(to_send);
            }
        }
    }

    virtual void onReceive(vector<double> data) {
        string s;
        for (int i = 0; i < data.size(); i++) {
            if (i > 0) s += "\t";
            s += to_string(data[i]);
        }
        s += "\n";
        if (!s.empty()) sendString(s);
    }

    bool start();

private:
    void sendString(const string& tosend);

    string getStreamString(uint32_t label) {
        if (use_tcp_stream_mapping_) return tcp_stream_mapping_[label];
        else return std::to_string(label) + "\n";
    }

    string server_;
    int port_;
    ofxTCPClient *client_;

    uint64_t elapsed_time_ = 0;
    std::map<uint32_t, string> tcp_stream_mapping_;
    bool use_tcp_stream_mapping_;

    bool is_in_retry_;
};

#endif