/Users/mourrain/Devel/mmx/basix/include/basix/port.hpp

Go to the documentation of this file.

/******************************************************************************
* MODULE     : port.hpp
* DESCRIPTION: Input and output ports
* COPYRIGHT  : (C) 2010  Joris van der Hoeven
*******************************************************************************
* This software falls under the GNU general public license and comes WITHOUT
* ANY WARRANTY WHATSOEVER. See the file $TEXMACS_PATH/LICENSE for more details.
* If you don't have this file, write to the Free Software Foundation, Inc.,
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
******************************************************************************/

#ifndef __PORT_HPP
#define __PORT_HPP
#include <basix/string.hpp>


namespace mmx {

extern bool texmacs_mode;
extern bool math_mode;

string string_as_mmx (const string& g);
string output_as_mmx (const generic& g);

/******************************************************************************
* The port class
******************************************************************************/

class port;
class port_rep: public rep_struct {
public:
  virtual syntactic expression () const = 0;
  virtual bool is_output_port ();
  virtual bool is_input_port ();
  virtual bool error_flag ();
  virtual string error_message ();
  virtual bool busy ();
  virtual nat  can_write ();
  virtual nat  can_read ();
  virtual void write (const char* s, nat n);
  virtual void read (char* s, nat n);
  virtual void flush ();
  virtual bool wait (int msecs);
  virtual port accept ();
  virtual port component (const string& name);
  virtual void format (const print_format& fm);

public:
  inline port_rep () {}
  inline virtual ~port_rep () {}
};

class port {
INDIRECT_PROTO (port, port_rep)
  port ();
};
INDIRECT_IMPL (port, port_rep)

HARD_TO_EXACT_IDENTITY_SUGAR(,port)
HARD_TO_TRUE_IDENTITY_SUGAR(,port)

inline syntactic flatten (const port& p) { return p->expression (); }

/******************************************************************************
* Public port constructors
******************************************************************************/

extern port mmin;
extern port mmout;
extern port mmerr;

port input_string_port (const string& s);
port output_string_port (string& s);
port input_output_string_port (string& s);
port input_file_port (const string& name);
port output_file_port (const string& name);
port input_output_file_port (const string& name);
port socket_server_port (const string& host, int port);
port socket_client_port (const string& host, int port);
port pipe_port (const string& cmd);
port composite_port (const vector<port>& ps);
port composite_port (const vector<port>& ps, const vector<string>& names);
port formatting_port (const port& p);
port error_port (const string& message);

/******************************************************************************
* Public routines for ports
******************************************************************************/

inline bool is_input_port (const port& p) {
  return inside (p)->is_input_port (); }
inline bool is_output_port (const port& p) {
  return inside (p)->is_output_port (); }
inline bool error_flag (const port& p) {
  return inside (p)->error_flag (); }
string error_message (const port& p);
inline bool busy (const port& p) {
  return inside (p)->busy (); }
inline nat can_write (const port& p) {
  return inside (p)->can_write (); }
inline nat can_read (const port& p) {
  return inside (p)->can_read (); }
inline void write (const port& p, const char* s, nat n) {
  inside (p)->write (s, n); }
inline void write (const port& p, const string& s) {
  inside (p)->write (inside (s, 0), N(s)); }
inline void read (const port& p, char* s, nat n) {
  inside (p)->read (s, n); }
inline string read (const port& p, nat n) {
  string r (n); inside (p)->read (inside (r, 0), n); return r; }
inline void flush (const port& p) {
  inside (p)->flush (); }
inline bool wait (const port& p, int msec) {
  return inside (p)->wait (msec); }
inline port accept (const port& p) {
  return inside (p)->accept (); }
port component (const port& p, const string& name);

nat wait_port_event (int msecs);

/******************************************************************************
* Standard << and >> operators
******************************************************************************/

typedef char* charp;
typedef const char* const_charp;

template<typename C> inline port
operator << (const port& out, const C& x) {
  write (out, output_as_mmx (as<generic> (x)));
  return out;
}

inline port
operator << (const port& out, const string& s) {
  write (out, string_as_mmx (s));
  return out;
}

inline port
operator << (const port& out, const charp& s) {
  write (out, string_as_mmx (s));
  return out;
}

inline port
operator << (const port& out, const const_charp& s) {
  write (out, string_as_mmx (s));
  return out;
}

inline port
operator << (const port& out, const char& c) {
  write (out, string_as_mmx (c));
  return out;
}

inline port
operator << (const port& out, const print_format& fm) {
  inside (out) -> format (fm);
  return out;
}

inline port
operator >> (const port& in, char& c) {
  read (in, &c, 1);
  return in;
}

/******************************************************************************
* Binary serialization
******************************************************************************/

template<typename C> generic binary_disassemble (const C& x);
template<typename C> C binary_assemble (const generic& x);
template<typename C> void binary_write (const port& out, const C& x);
template<typename C> C binary_read (const port& in);

template<typename C>
struct void_binary_helper {
  static inline string short_type_name () { return "?"; }
  static inline generic full_type_name () { return "?"; }
  static inline nat size (const C& x) {
    return vector_size (disassemble (x)); }
  static inline generic access (const C& x, nat i) {
    return vector_access (disassemble (x), i); }
  static inline generic disassemble (const C& x) {
    return as<generic> (x); }
  static inline C assemble (const generic& x) {
    return as<C> (x); }
  static inline void write (const port& out, const C& x) {
    generic d= binary_disassemble<C> (x);
    ASSERT (is<string> (d) || !is<C> (d), "binary write not implemented");
    binary_write<generic> (out, d); }
  static inline C read (const port& in) {
    return binary_assemble<C> (binary_read<generic> (in)); }
};

template<typename C>
struct binary_helper:
  public void_binary_helper<C> {};

template<typename C> nat
binary_size (const C& x) {
  return binary_helper<C>::size (x);
}

template<typename C> generic
binary_access (const C& x, nat i) {
  return binary_helper<C>::access (x, i);
}

template<typename C> generic
binary_disassemble (const C& x) {
  return binary_helper<C>::disassemble (x);
}

template<typename C> C
binary_assemble (const generic& x) {
  return binary_helper<C>::assemble (x);
}

template<typename C> void
binary_write (const port& out, const C& x) {
  binary_helper<C>::write (out, x);
}

template<typename C> C
binary_read (const port& in) {
  return binary_helper<C>::read (in);
}

template<typename C> port
binary_ll (const port& out, const C& x) {
  binary_helper<C>::write (out, x);
  return out;
}

template<typename C> port
binary_rr (const port& in, C& x) {
  x= binary_helper<C>::read (in);
  return in;
}

#define Short_type_name(T) binary_helper<T >::short_type_name ()
#define Full_type_name(T) binary_helper<T >::full_type_name ()

/******************************************************************************
* Binary serialization of generic objects
******************************************************************************/

typedef generic (*unary_generic) (const generic&);

void attach_generic_binary_assembler (const generic&, unary_generic);
generic binary_type_generic (const generic& g);
generic binary_disassemble_generic (const generic& g);
generic binary_assemble_generic (const generic& tp, const generic& val);

template<typename T> generic
binary_assemble_generic_via (const generic& x) {
  return as<generic> (binary_assemble<T> (x));
} 

template<typename T> inline void
attach_generic_binary_assembler () {
  attach_generic_binary_assembler (binary_helper<T>::full_type_name (),
                                   binary_assemble_generic_via<T>);
}

void attach_generic_binary_reader (const string&, unary_generic);
void binary_write_generic (const port& out, const generic& g);
generic binary_read_generic (const port& in);

template<typename T> generic
binary_read_generic (const generic& in) {
  return as<generic> (binary_read<T> (as<port> (in)));
} 

template<typename T> inline void
attach_generic_binary_reader () {
  attach_generic_binary_reader (binary_helper<T>::short_type_name (),
                                binary_read_generic<T>);
}

template<>
struct binary_helper<generic> {
  static inline string short_type_name () { return "Gen"; }
  static inline generic full_type_name () { return "Generic"; }
  static inline nat size (const generic& g) { (void) g; return 2; }
  static inline generic access (const generic& x, nat i) {
    if (i == 0) return binary_type_generic (x);
    else if (i == 1) return binary_disassemble_generic (x);
    else ERROR ("index out of range"); }
  static inline generic disassemble (const generic& x) {
    return gen_vec (access (x, 0), access (x, 1)); }
  static inline generic assemble (const generic& x) {
    return binary_assemble_generic (vector_access (x, 0),
                                    vector_access (x, 1)); }
  static inline void write (const port& out, const generic& g) {
    binary_write_generic (out, g); }
  static generic read (const port& in) {
    return binary_read_generic (in); }
};

inline generic generic_disassemble (const generic& x) {
  return binary_disassemble<generic> (x); }
inline generic generic_assemble (const generic& x) {
  return binary_assemble<generic> (x); }

/******************************************************************************
* Binary serialization of standard numeric types
******************************************************************************/

#define NUMERIC_BINARY_HELPER(TMPL,C,name,fname)                         \
TMPL                                                                     \
 struct binary_helper< C >: public void_binary_helper< C > {             \
  static inline string short_type_name () { return name; }               \
  static inline generic full_type_name () { return fname; }              \
  static inline generic disassemble (const C& x) {                       \
  return as<generic> (numeric_as_string (x)); }                          \
  static inline C assemble (const generic& x) {                          \
    return string_as_numeric<C> (as<string> (x)); }                      \
  static inline void write (const port& out, const C& x) {               \
    mmx::write (out, (const char*) ((const void*) (&x)), sizeof (C)); }  \
  static inline C read (const port& in) {                                \
    C x; mmx::read (in, (char*) ((void*) (&x)), sizeof (C)); return x; } \
};

NUMERIC_BINARY_HELPER(STMPL,char,"C","Char")
NUMERIC_BINARY_HELPER(STMPL,uchar,"Uc","Uchar")
NUMERIC_BINARY_HELPER(STMPL,short,"Sh","Short")
NUMERIC_BINARY_HELPER(STMPL,ushort,"Us","Ushort")
NUMERIC_BINARY_HELPER(STMPL,int,"I","Int")
NUMERIC_BINARY_HELPER(STMPL,nat,"N","Uint")
NUMERIC_BINARY_HELPER(STMPL,long,"Lo","Long")
NUMERIC_BINARY_HELPER(STMPL,ulong,"Ul","Ulong")
NUMERIC_BINARY_HELPER(STMPL,float,"F","Float")
NUMERIC_BINARY_HELPER(STMPL,double,"D","Double")

/******************************************************************************
* Binary serialization of other basic types
******************************************************************************/

template<>
struct binary_helper<bool>: public void_binary_helper<bool> {
  static inline string short_type_name () { return "B"; }
  static inline generic full_type_name () { return "Boolean"; }
  static inline generic disassemble (const bool& b) {
    return as<generic> (b? string ("true"): string ("false")); }
  static inline bool assemble (const generic& x) {
    return is<string> (x) && as<string> (x) == "true"; }
  static inline void write (const port& out, const bool& b) {
    mmx::write (out, b? "t": "f", 1); }
  static inline bool read (const port& in) {
    char s[1]; mmx::read (in, s, 1); return s[0] == 't'; }
};

template<>
struct binary_helper<string>: public void_binary_helper<string> {
  static inline string short_type_name () { return "S"; }
  static inline generic full_type_name () { return "String"; }
  static inline void write (const port& out, const string& s) {
    binary_write<nat> (out, N(s));
    mmx::write (out, s); }
  static inline string read (const port& in) {
    nat n= binary_read<nat> (in);
    return mmx::read (in, n); }
};

template<>
struct binary_helper<syntactic>: public void_binary_helper<syntactic> {
  static inline string short_type_name () { return "Y"; }
  static inline generic full_type_name () { return "Syntactic"; }
  static inline generic disassemble (const syntactic& x) {
    return *x; }
  static inline syntactic assemble (const generic& x) {
    return as_syntactic (x); }
  static inline void write (const port& out, const syntactic& s) {
    binary_write<generic> (out, *s); }
  static inline syntactic read (const port& in) {
    return as_syntactic (binary_read<generic> (in)); }
};

template<>
struct binary_helper<exception>: public void_binary_helper<exception> {
  static inline string short_type_name () { return "Exc"; }
  static inline generic full_type_name () { return "Exception"; }
  static inline generic disassemble (const exception& x) {
    return *x; }
  static inline exception assemble (const generic& x) {
    return exception (x); }
  static inline void write (const port& out, const exception& e) {
    binary_write<generic> (out, *e); }
  static inline exception read (const port& in) {
    return exception (binary_read<generic> (in)); }
};

template<typename FT, typename T>
struct format_binary_helper {
  static inline void write (const port& out, const format<T>& fm) {
    binary_write<T> (out, get_sample (fm)); }
  static inline format<T> read (const port& in) {
    return get_format (binary_read<T> (in)); }
};

template<typename T>
struct format_binary_helper<empty_format,T> {
  static inline void write (const port&, const format<T>&) {}
  static inline format<T> read (const port&) { return format<T> (); }
};

template<typename T>
struct binary_helper<format<T> >: public void_binary_helper<format<T> > {
  typedef typename format<T>::FT FT;
  static inline string short_type_name () {
    return "Fm" * Short_type_name (T); }
  static inline generic full_type_name () {
    return gen ("Format", Full_type_name (T)); }
  static inline generic disassemble (const format<T>& fm) {
    return binary_disassemble (get_sample (fm)); }
  static inline format<T>  assemble (const generic& x) {
    return get_format (binary_assemble<T> (x)); }
  static inline void write (const port& out, const format<T>& fm) {
    format_binary_helper<FT,T>::write (out, fm); }
  static inline format<T> read (const port& in) {
    return format_binary_helper<FT,T>::read (in); }
};

} // namespace mmx
#endif // __PORT_HPP