hazy_message.h

Go to the documentation of this file.

#ifndef HAZY_MESSAGE_H
#define HAZY_MESSAGE_H
#include <string.h>
#include "globals.h"


enum message_type {READ_SE_EAGER, READ_SE_LAZY_NAIVE, READ_SE_LAZY_HAZY, READ_COUNT, UPDATE, QUERY_SERVER_ID, CLOSE_CONNECTION, SERVER_NOOP, CREATE_VIEW, READ_SE_LAZY_NAIVE_BIN, READ_SE_LAZY_HAZY_BIN, UPDATE_BIN, DELETE_BIN};

struct se_lazy_naive_msg_bin_header {
  enum message_type t; 
  int view_id;
  int payload_size;
};

struct update_bin_header {
  enum message_type t; 
  int view_id;
  int label;
  int payload_size;
};

struct se_lazy_hazy_msg_bin_header {
  enum message_type t;
  int view_id;
  double eps;
  int payload_size;
};

struct delete_bin_header {
  enum message_type t;
  int view_id;
  int deleted_id;
  int db_name_size;
  int table_name_size;
};


typedef void* message_data;

const char szDelim = '|';
const int CONVERT_CHAR_TO_INT = 48;
const char done_msg[6] = "done|";

#ifdef __cplusplus
extern "C"  {
#endif


  int build_read_se_answer(int entity_label, message_data msg, unsigned int nMaxSize);
  int build_read_count_answer(int count, message_data msg, unsigned int nMaxSize);
  int build_update_answer(message_data msg, unsigned int nMaxSize);
  int build_delete_answer(message_data msg, unsigned int nMaxSize);

  int build_query_server_answer(int id, message_data msg, unsigned int nMaxSize);
  int build_close_connection_answer(int close_conn, message_data msg, unsigned int nMaxSize);
  
  int build_noop_server_answer(int acknowledge, message_data msg, unsigned int nMaxSize);

  int build_create_view_answer(message_data msg, unsigned int nMaxSize);
  

  int build_se_eager_msg(const int view_id, const int entity_id, message_data msg, unsigned int nMaxSize);
  int build_se_lazy_naive_msg(const int view_id, const char *vector_str, message_data msg, unsigned int nMaxSize);
  int build_se_lazy_hazy_msg(const int view_id, const char *vector_str, const double eps, message_data msg, unsigned int nMaxSize);
  int build_count_msg(const int view_id, message_data msg, unsigned int nMaxSize);
  int build_update_msg(const int view_id, const char *update_example, message_data msg, unsigned int nMaxSize);
  int build_query_server_id_msg(message_data msg, unsigned int nMaxSize);
  int build_close_connection_msg(message_data msg, unsigned int nMaxSize);
  
  int build_noop_server_msg(message_data msg, unsigned int nMaxSize);
  

  enum message_type get_message_type(const message_data msg);  
  
  int
  build_se_lazy_naive_msg_bin(const int view_id, const void* vector_ptr, size_t vec_size, 
                              void* _out, size_t *out_size, unsigned int nMaxSize);
  
  int
  build_se_lazy_hazy_msg_bin(const int view_id, const double eps, const void* vector_ptr, size_t vec_size,
                             void* _out, size_t *out_size, unsigned int nMaxSize);

  int
  build_delete_msg_bin(const int view_id, const int entity_id, const void *db_name_ptr, size_t db_name_ptr_size,
                       const void *table_name_ptr, size_t table_name_ptr_size,
                       void *_out, size_t *out_size, unsigned int nMaxSize);
  
#ifdef __cplusplus
}
#endif

#ifdef __cplusplus
#include <string>
#include <iostream>
#include <sstream>
#include "vectors.h"
#include "hazy_model.h"

struct create_view_bin_str {
  enum message_type t;
  int view_id;
  enum storage_manager_type sm;
  int dense;
  int useepsmap;
  hazy_model::strategy hazy_strategy;
  int reservoir_size;
  double resort_time;
  double tao_val;
  double alpha_ratio;
  int buffer_size;
  std::string view_name;
  std::string view_key;
  std::string entity_table_name;
  std::string entity_table_key;
  std::string training_table_name;
  int dim;
  std::string db_name;
  double m_factor;
};

int
build_create_view_msg(struct create_view_bin_str *s, message_data _out, unsigned int nMaxSize);


void parse_se_eager_msg(const message_data msg, int &view_id, int &entity_id);  

void parse_view_id_in_se_eager_msg(const message_data msg, int &view_id);

void parse_count_msg(const message_data msg, int &view_id); 

void parse_delete_msg_bin(message_data msg, int &view_id, int &entity_id, std::string &db_name, std::string &training_table_name);

void parse_view_id_in_delete_msg_bin(message_data msg, int &view_id);

// Templates
template<class T>
void parse_se_lazy_naive_msg(message_data msg, int &view_id, T &vec) {
  std::stringstream parser;
  parser << (char *) msg;
  std::string parsed_word;
  
  //gets message type
  std::getline(parser, parsed_word, szDelim);
  //gets view_id
  std::getline(parser, parsed_word, szDelim);
  view_id = atoi(parsed_word.c_str());
  //gets vector_id
  std::getline(parser, parsed_word, szDelim);
  vec.fromPSQL(parsed_word);
}

void parse_view_id_in_se_lazy_naive_msg(message_data msg, int &view_id);

// Templates
template<class T>
void parse_se_lazy_naive_msg_bin(void* msg, int &view_id, T &vec) {
  struct se_lazy_naive_msg_bin_header* msg_header = (struct se_lazy_naive_msg_bin_header*)msg;
  assert(msg_header->t == READ_SE_LAZY_NAIVE_BIN);
  view_id          = msg_header->view_id;
  int payload_size = msg_header->payload_size;
  vec.read_bin((void*) (&msg_header[1]), payload_size);
}


void parse_view_id_in_se_lazy_naive_msg_bin(void* msg, int &view_id);

template<class T>
void parse_se_lazy_hazy_msg(message_data msg, int &view_id, T &vec, double &eps) {
  std::stringstream parser;
  parser << (char *) msg;
  std::string parsed_word;
  
  //gets message type
  std::getline(parser, parsed_word, szDelim);
  //gets view_id
  std::getline(parser, parsed_word, szDelim);
  view_id = atoi(parsed_word.c_str());
  //gets vector_id
  std::getline(parser, parsed_word, szDelim);
  vec.fromPSQL(parsed_word);
  //gets eps
  std::getline(parser, parsed_word, szDelim);
  eps = atof(parsed_word.c_str());
}


void parse_view_id_in_se_lazy_hazy_msg(message_data msg, int &view_id);

// Templates
template<class T>
void parse_se_lazy_hazy_msg_bin(void* msg, int &view_id, T &vec, double &eps) {
  struct se_lazy_hazy_msg_bin_header* msg_header = (struct se_lazy_hazy_msg_bin_header*)msg;
  assert(msg_header->t == READ_SE_LAZY_HAZY_BIN);
  view_id          = msg_header->view_id;
  eps              = msg_header->eps;
  int payload_size = msg_header->payload_size;
  vec.read_bin((void*) (&msg_header[1]), payload_size);
}

void parse_view_id_in_se_lazy_hazy_msg_bin(void* msg, int &view_id);

template<class T>
void parse_update_msg(message_data msg, int &view_id, T &vec, int &classOfExample) {
  std::stringstream parser;
  parser << (char *) msg;
  std::string parsed_word;
  
  //gets message type
  std::getline(parser, parsed_word, szDelim);
  //gets view_id
  std::getline(parser, parsed_word, szDelim);
  view_id = atoi(parsed_word.c_str());
  //gets vector_id
  std::getline(parser, parsed_word, szDelim);
  parse_labeled_vector<T>(parsed_word, classOfExample, vec);
}

void parse_view_id_in_update_msg(message_data msg, int &view_id);

template<class T>
void parse_update_msg_bin(message_data msg, int &view_id, T &vec, int &classOfExample) {
  struct update_bin_header *msg_header = (struct update_bin_header*) msg;
  assert(msg_header->t == UPDATE_BIN);
  view_id              = msg_header->view_id;
  classOfExample       = msg_header->label;
  int payload_size     = msg_header->payload_size;
  vec.read_bin((void*) (&msg_header[1]), payload_size);
}

void parse_view_id_in_update_msg_bin(message_data msg, int &view_id);

void parse_create_view_msg(message_data msg, struct create_view_bin_str *cv_struct);

#endif // _cpluspc


#endif

---