/Users/mourrain/Devel/mmx/basix/src/composite_port.cpp

Go to the documentation of this file.

/******************************************************************************
* MODULE     : composite_port.cpp
* DESCRIPTION: Aggregation of several 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.
******************************************************************************/

#include <basix/port.hpp>
#include <basix/string.hpp>
#include <basix/vector.hpp>
#include <basix/identifiers.hpp>


namespace mmx {

/******************************************************************************
* Composite ports
******************************************************************************/

class composite_port_rep: public port_rep {
  vector<port>   ps;
  vector<string> names;

public:
  syntactic expression () const {
    vector<syntactic> v;
    for (nat i=0; i<N(ps); i++)
      v << syn (GEN_TYPE, syntactic (names[i]), flatten (ps[i]));
    return syn ("composite_port", v);
  }

  bool is_output_port () {
    for (nat i=0; i<N(ps); i++)
      if (mmx::is_output_port (ps[i]))
        return true;
    return false;
  }
  bool is_input_port () {
    for (nat i=0; i<N(ps); i++)
      if (mmx::is_input_port (ps[i]))
        return true;
    return false;
  }
  bool error_flag () {
    for (nat i=0; i<N(ps); i++)
      if (mmx::error_flag (ps[i]))
        return true;
    return false;
  }
  string error_message () {
    for (nat i=0; i<N(ps); i++)
      if (mmx::error_flag (ps[i]))
        return mmx::error_message (ps[i]);
    return "";
  }
  bool busy () {
    for (nat i=0; i<N(ps); i++)
      if (mmx::busy (ps[i]))
        return true;
    return false;
  }
  nat can_write () {
    nat r= (nat) (-1);
    for (nat i=0; i<N(ps); i++)
      if (mmx::is_output_port (ps[i]))
        r= min (r, mmx::can_write (ps[i]));
    return r;
  }
  nat can_read () {
    nat r= 0;
    for (nat i=0; i<N(ps); i++)
      if (mmx::is_input_port (ps[i]))
        r += mmx::can_read (ps[i]);
    return r;
  }
  void write (const char* s, nat n) {
    for (nat i=0; i<N(ps); i++)
      if (mmx::is_output_port (ps[i]))
        mmx::write (ps[i], s, n);
  }
  void read (char* s, nat n) {
    while (n > 0)
      for (nat i=0; i<N(ps); i++)
        if (n > 0 && mmx::is_input_port (ps[i])) {
          nat k= min (n, mmx::can_read (ps[i]));
          if (k > 0) mmx::read (ps[i], s, k);
          s += k;
          n -= k;
        }
    ASSERT (n == 0, "read failed");
  }
  void flush () {
    for (nat i=0; i<N(ps); i++)
      if (mmx::is_output_port (ps[i]))
        mmx::flush (ps[i]);
  }
  bool wait (int msecs) {
    for (nat i=0; i<N(ps); i++)
      if (mmx::is_input_port (ps[i])) {
        nat delay= min (msecs, 1);
        if (mmx::wait (ps[i], delay)) return true;
        msecs -= delay;
      }
    return false;
  }
  port component (const string& name) {
    for (nat i=0; i<N(ps); i++)
      if (name == names[i])
        return ps[i];
    ERROR ("port not found");
  }

public:
  inline composite_port_rep (const vector<port>& p2, const vector<string>& n2):
    ps (p2), names (n2) {}
};

/******************************************************************************
* Composite ports
******************************************************************************/

port
composite_port (const vector<port>& ps, const vector<string>& names) {
  ASSERT (N(ps) == N(names), "lengths do not match");
  return (port_rep*) new composite_port_rep (ps, names);
}

port
composite_port (const vector<port>& ps) {
  nat i, n= N(ps);
  vector<string> names= fill<string> (n);
  for (i=0; i<n; i++) names[i]= as_string (i);
  return composite_port (ps, names);
}

} // namespace mmx