/Users/mourrain/Devel/mmx/basix/glue/glue_port.cpp

Go to the documentation of this file.

#include <basix/vector.hpp>
#include <basix/port.hpp>
#include <basix/tuple.hpp>
#include <basix/glue.hpp>

namespace mmx {
  static port
  GLUE_1 (const string &arg_1) {
    return input_string_port (arg_1);
  }
  
  static port
  GLUE_2 (const string &arg_1) {
    return input_file_port (arg_1);
  }
  
  static port
  GLUE_3 (const string &arg_1) {
    return output_file_port (arg_1);
  }
  
  static port
  GLUE_4 (const string &arg_1, const int &arg_2) {
    return socket_server_port (arg_1, arg_2);
  }
  
  static port
  GLUE_5 (const string &arg_1, const int &arg_2) {
    return socket_client_port (arg_1, arg_2);
  }
  
  static port
  GLUE_6 (const string &arg_1) {
    return pipe_port (arg_1);
  }
  
  static port
  GLUE_7 (const tuple<port> &arg_1) {
    return composite_port (as_vector (arg_1));
  }
  
  static port
  GLUE_8 (const string &arg_1) {
    return error_port (arg_1);
  }
  
  static bool
  GLUE_9 (const port &arg_1) {
    return is_output_port (arg_1);
  }
  
  static bool
  GLUE_10 (const port &arg_1) {
    return is_input_port (arg_1);
  }
  
  static bool
  GLUE_11 (const port &arg_1) {
    return error_flag (arg_1);
  }
  
  static string
  GLUE_12 (const port &arg_1) {
    return error_message (arg_1);
  }
  
  static bool
  GLUE_13 (const port &arg_1) {
    return busy (arg_1);
  }
  
  static int
  GLUE_14 (const port &arg_1) {
    return can_write (arg_1);
  }
  
  static int
  GLUE_15 (const port &arg_1) {
    return can_read (arg_1);
  }
  
  static void
  GLUE_16 (const port &arg_1, const string &arg_2) {
    write (arg_1, arg_2);
  }
  
  static string
  GLUE_17 (const port &arg_1, const int &arg_2) {
    return read (arg_1, arg_2);
  }
  
  static void
  GLUE_18 (const port &arg_1) {
    flush (arg_1);
  }
  
  static bool
  GLUE_19 (const port &arg_1, const int &arg_2) {
    return wait (arg_1, arg_2);
  }
  
  static port
  GLUE_20 (const port &arg_1) {
    return accept (arg_1);
  }
  
  static port
  GLUE_21 (const port &arg_1, const string &arg_2) {
    return component (arg_1, arg_2);
  }
  
  static int
  GLUE_22 (const int &arg_1) {
    return wait_port_event (arg_1);
  }
  
  static port
  GLUE_23 (const port &arg_1, const generic &arg_2) {
    return arg_1 << arg_2;
  }
  
  static port
  GLUE_24 (const port &arg_1, const string &arg_2) {
    return arg_1 << arg_2;
  }
  
  static generic
  GLUE_25 (const generic &arg_1) {
    return generic_assemble (arg_1);
  }
  
  static generic
  GLUE_26 (const generic &arg_1) {
    return generic_disassemble (arg_1);
  }
  
  static void
  GLUE_27 (const port &arg_1, const generic &arg_2) {
    binary_write_generic (arg_1, arg_2);
  }
  
  static generic
  GLUE_28 (const port &arg_1) {
    return binary_read_generic (arg_1);
  }
  
  void
  glue_port () {
    static bool done = false;
    if (done) return;
    done = true;
    call_glue (string ("glue_string"));
    define_type<port > (lit ("Port"));
    define_constant<port > ("mmin", mmin);
    define_constant<port > ("mmout", mmout);
    define_constant<port > ("mmerr", mmerr);
    define ("input_string_port", GLUE_1);
    define ("input_file_port", GLUE_2);
    define ("output_file_port", GLUE_3);
    define ("socket_server_port", GLUE_4);
    define ("socket_client_port", GLUE_5);
    define ("pipe_port", GLUE_6);
    define ("composite_port", GLUE_7);
    define ("error_port", GLUE_8);
    define (".output_port?", GLUE_9);
    define (".input_port?", GLUE_10);
    define (".error?", GLUE_11);
    define (".error", GLUE_12);
    define (".busy?", GLUE_13);
    define (".can_write", GLUE_14);
    define (".can_read", GLUE_15);
    define ("write", GLUE_16);
    define ("read", GLUE_17);
    define ("flush", GLUE_18);
    define ("wait", GLUE_19);
    define ("accept", GLUE_20);
    define (".[]", GLUE_21);
    define ("wait", GLUE_22);
    define ("<<", GLUE_23);
    define ("<<", GLUE_24);
    define ("binary_assemble", GLUE_25);
    define ("binary_disassemble", GLUE_26);
    define ("binary_write", GLUE_27);
    define ("binary_read", GLUE_28);
  }
}