Merged branch 'msg-passing' from http://gnuradio.org/git/eb.git

This is work in progress on the message passing implementation.

Passes distcheck.

Signed-off-by: Johnathan Corgan <jcorgan@corganenterprises.com>

diff --combined gruel/src/include/gruel/pmt.h
index caa12209d56da8500176d0df915e3bd5298109e5,ed337a885a3ae392197fd123ed3fcedccebb3e77..2403593017f52ea79265e6a632f935d932465a28
--- 1/gruel/src/include/gruel/pmt.h
--- 2/gruel/src/include/gruel/pmt.h
+++ b/gruel/src/include/gruel/pmt.h
@@@ -23,7 -23,7 +23,7 @@@
  #ifndef INCLUDED_PMT_H
  #define INCLUDED_PMT_H
  
 -#include <boost/shared_ptr.hpp>
 +#include <boost/intrusive_ptr.hpp>
  #include <boost/any.hpp>
  #include <complex>
  #include <string>
@@@ -50,10 -50,8 +50,10 @@@ class pmt_base
   * \brief typedef for shared pointer (transparent reference counting).
   * See http://www.boost.org/libs/smart_ptr/smart_ptr.htm
   */
 -typedef boost::shared_ptr<pmt_base> pmt_t;
 +typedef boost::intrusive_ptr<pmt_base> pmt_t;
  
 +extern void intrusive_ptr_add_ref(pmt_base*);
 +extern void intrusive_ptr_release(pmt_base*);
  
  class pmt_exception : public std::logic_error
  {
@@@ -237,6 -235,42 +237,42 @@@ pmt_t pmt_cddr(pmt_t pair)
  pmt_t pmt_caddr(pmt_t pair);
  pmt_t pmt_cadddr(pmt_t pair);
  
+ /*
+  * ------------------------------------------------------------------------
+  *                              Tuples
+  *
+  * Store a fixed number of objects.  Tuples are not modifiable, and thus
+  * are excellent for use as messages.  Indexing is zero based.
+  * Access time to an element is O(1).
+  * ------------------------------------------------------------------------
+  */
+ 
+ //! Return true if \p x is a tuple, othewise false.
+ bool pmt_is_tuple(pmt_t x);
+ 
+ pmt_t pmt_make_tuple();
+ pmt_t pmt_make_tuple(const pmt_t &e0);
+ pmt_t pmt_make_tuple(const pmt_t &e0, const pmt_t &e1);
+ pmt_t pmt_make_tuple(const pmt_t &e0, const pmt_t &e1, const pmt_t &e2);
+ pmt_t pmt_make_tuple(const pmt_t &e0, const pmt_t &e1, const pmt_t &e2, const pmt_t &e3);
+ pmt_t pmt_make_tuple(const pmt_t &e0, const pmt_t &e1, const pmt_t &e2, const pmt_t &e3, const pmt_t &e4);
+ pmt_t pmt_make_tuple(const pmt_t &e0, const pmt_t &e1, const pmt_t &e2, const pmt_t &e3, const pmt_t &e4, const pmt_t &e5);
+ pmt_t pmt_make_tuple(const pmt_t &e0, const pmt_t &e1, const pmt_t &e2, const pmt_t &e3, const pmt_t &e4, const pmt_t &e5, const pmt_t &e6);
+ pmt_t pmt_make_tuple(const pmt_t &e0, const pmt_t &e1, const pmt_t &e2, const pmt_t &e3, const pmt_t &e4, const pmt_t &e5, const pmt_t &e6, const pmt_t &e7);
+ pmt_t pmt_make_tuple(const pmt_t &e0, const pmt_t &e1, const pmt_t &e2, const pmt_t &e3, const pmt_t &e4, const pmt_t &e5, const pmt_t &e6, const pmt_t &e7, const pmt_t &e8);
+ pmt_t pmt_make_tuple(const pmt_t &e0, const pmt_t &e1, const pmt_t &e2, const pmt_t &e3, const pmt_t &e4, const pmt_t &e5, const pmt_t &e6, const pmt_t &e7, const pmt_t &e8, const pmt_t &e9);
+ 
+ /*!
+  * If \p x is a vector or proper list, return a tuple containing the elements of x
+  */
+ pmt_t pmt_to_tuple(const pmt_t &x);
+ 
+ /*!
+  * Return the contents of position \p k of \p tuple.
+  * \p k must be a valid index of \p tuple.
+  */
+ pmt_t pmt_tuple_ref(const pmt_t &tuple, size_t k);
+ 
  /*
   * ------------------------------------------------------------------------
   *                           Vectors

diff --combined gruel/src/lib/pmt/pmt.cc
index fd4035f75f8687e8029a25cdf69ac2546c4c7452,20dc4e42c403014b37d0f36fcbebd9a2889dea32..f0e3c30a266f630a78252e0c4a2a35f2cfb7a918
--- 1/gruel/src/lib/pmt/pmt.cc
--- 2/gruel/src/lib/pmt/pmt.cc
+++ b/gruel/src/lib/pmt/pmt.cc
@@@ -56,8 -56,6 +56,8 @@@ pmt_base::operator delete(void *p, size
  
  #endif
  
 +void intrusive_ptr_add_ref(pmt_base* p) { ++(p->count_); }
 +void intrusive_ptr_release(pmt_base* p) { if (--(p->count_) == 0 ) delete p; }
  
  pmt_base::~pmt_base()
  {
@@@ -128,6 -126,12 +128,12 @@@ _vector(pmt_t x
    return dynamic_cast<pmt_vector*>(x.get());
  }
  
+ static pmt_tuple *
+ _tuple(pmt_t x)
+ {
+   return dynamic_cast<pmt_tuple*>(x.get());
+ }
+ 
  static pmt_uniform_vector *
  _uniform_vector(pmt_t x)
  {
@@@ -496,6 -500,201 +502,201 @@@ pmt_vector_fill(pmt_t vector, pmt_t obj
    _vector(vector)->fill(obj);
  }
  
+ ////////////////////////////////////////////////////////////////////////////
+ //                             Tuples
+ ////////////////////////////////////////////////////////////////////////////
+ 
+ pmt_tuple::pmt_tuple(size_t len)
+   : d_v(len)
+ {
+ }
+ 
+ pmt_t
+ pmt_tuple::ref(size_t k) const
+ {
+   if (k >= length())
+     throw pmt_out_of_range("pmt_tuple_ref", pmt_from_long(k));
+   return d_v[k];
+ }
+ 
+ bool
+ pmt_is_tuple(pmt_t obj)
+ {
+   return obj->is_tuple();
+ }
+ 
+ pmt_t
+ pmt_tuple_ref(const pmt_t &tuple, size_t k)
+ {
+   if (!tuple->is_tuple())
+     throw pmt_wrong_type("pmt_tuple_ref", tuple);
+   return _tuple(tuple)->ref(k);
+ }
+ 
+ // for (i=0; i < 10; i++)
+ //   make_constructor()
+ 
+ pmt_t
+ pmt_make_tuple()
+ {
+   return pmt_t(new pmt_tuple(0));
+ }
+ 
+ pmt_t
+ pmt_make_tuple(const pmt_t &e0)
+ {
+   pmt_tuple *t = new pmt_tuple(1);
+   t->_set(0, e0);
+   return pmt_t(t);
+ }
+ 
+ pmt_t
+ pmt_make_tuple(const pmt_t &e0, const pmt_t &e1)
+ {
+   pmt_tuple *t = new pmt_tuple(2);
+   t->_set(0, e0);
+   t->_set(1, e1);
+   return pmt_t(t);
+ }
+ 
+ pmt_t
+ pmt_make_tuple(const pmt_t &e0, const pmt_t &e1, const pmt_t &e2)
+ {
+   pmt_tuple *t = new pmt_tuple(3);
+   t->_set(0, e0);
+   t->_set(1, e1);
+   t->_set(2, e2);
+   return pmt_t(t);
+ }
+ 
+ pmt_t
+ pmt_make_tuple(const pmt_t &e0, const pmt_t &e1, const pmt_t &e2, const pmt_t &e3)
+ {
+   pmt_tuple *t = new pmt_tuple(4);
+   t->_set(0, e0);
+   t->_set(1, e1);
+   t->_set(2, e2);
+   t->_set(3, e3);
+   return pmt_t(t);
+ }
+ 
+ pmt_t
+ pmt_make_tuple(const pmt_t &e0, const pmt_t &e1, const pmt_t &e2, const pmt_t &e3, const pmt_t &e4)
+ {
+   pmt_tuple *t = new pmt_tuple(5);
+   t->_set(0, e0);
+   t->_set(1, e1);
+   t->_set(2, e2);
+   t->_set(3, e3);
+   t->_set(4, e4);
+   return pmt_t(t);
+ }
+ 
+ pmt_t
+ pmt_make_tuple(const pmt_t &e0, const pmt_t &e1, const pmt_t &e2, const pmt_t &e3, const pmt_t &e4, const pmt_t &e5)
+ {
+   pmt_tuple *t = new pmt_tuple(6);
+   t->_set(0, e0);
+   t->_set(1, e1);
+   t->_set(2, e2);
+   t->_set(3, e3);
+   t->_set(4, e4);
+   t->_set(5, e5);
+   return pmt_t(t);
+ }
+ 
+ pmt_t
+ pmt_make_tuple(const pmt_t &e0, const pmt_t &e1, const pmt_t &e2, const pmt_t &e3, const pmt_t &e4, const pmt_t &e5, const pmt_t &e6)
+ {
+   pmt_tuple *t = new pmt_tuple(7);
+   t->_set(0, e0);
+   t->_set(1, e1);
+   t->_set(2, e2);
+   t->_set(3, e3);
+   t->_set(4, e4);
+   t->_set(5, e5);
+   t->_set(6, e6);
+   return pmt_t(t);
+ }
+ 
+ pmt_t
+ pmt_make_tuple(const pmt_t &e0, const pmt_t &e1, const pmt_t &e2, const pmt_t &e3, const pmt_t &e4, const pmt_t &e5, const pmt_t &e6, const pmt_t &e7)
+ {
+   pmt_tuple *t = new pmt_tuple(8);
+   t->_set(0, e0);
+   t->_set(1, e1);
+   t->_set(2, e2);
+   t->_set(3, e3);
+   t->_set(4, e4);
+   t->_set(5, e5);
+   t->_set(6, e6);
+   t->_set(7, e7);
+   return pmt_t(t);
+ }
+ 
+ pmt_t
+ pmt_make_tuple(const pmt_t &e0, const pmt_t &e1, const pmt_t &e2, const pmt_t &e3, const pmt_t &e4, const pmt_t &e5, const pmt_t &e6, const pmt_t &e7, const pmt_t &e8)
+ {
+   pmt_tuple *t = new pmt_tuple(9);
+   t->_set(0, e0);
+   t->_set(1, e1);
+   t->_set(2, e2);
+   t->_set(3, e3);
+   t->_set(4, e4);
+   t->_set(5, e5);
+   t->_set(6, e6);
+   t->_set(7, e7);
+   t->_set(8, e8);
+   return pmt_t(t);
+ }
+ 
+ pmt_t
+ pmt_make_tuple(const pmt_t &e0, const pmt_t &e1, const pmt_t &e2, const pmt_t &e3, const pmt_t &e4, const pmt_t &e5, const pmt_t &e6, const pmt_t &e7, const pmt_t &e8, const pmt_t &e9)
+ {
+   pmt_tuple *t = new pmt_tuple(10);
+   t->_set(0, e0);
+   t->_set(1, e1);
+   t->_set(2, e2);
+   t->_set(3, e3);
+   t->_set(4, e4);
+   t->_set(5, e5);
+   t->_set(6, e6);
+   t->_set(7, e7);
+   t->_set(8, e8);
+   t->_set(9, e9);
+   return pmt_t(t);
+ }
+ 
+ pmt_t
+ pmt_to_tuple(const pmt_t &x)
+ {
+   if (x->is_tuple())          // already one
+     return x;
+ 
+   size_t len = pmt_length(x);
+   pmt_tuple *t = new pmt_tuple(len);
+   pmt_t r = pmt_t(t);
+ 
+   if (x->is_vector()){
+     for (size_t i = 0; i < len; i++)
+       t->_set(i, _vector(x)->ref(i));
+     return r;
+   }
+ 
+   if (x->is_pair()){
+     pmt_t y = x;
+     for (size_t i = 0; i < len; i++){
+       t->_set(i, pmt_car(y));
+       y = pmt_cdr(y);
+     }
+     return r;
+   }
+ 
+   throw pmt_wrong_type("pmt_to_tuple", x);
+ }
+ 
+ 
+ 
  ////////////////////////////////////////////////////////////////////////////
  //                       Uniform Numeric Vectors
  ////////////////////////////////////////////////////////////////////////////
@@@ -730,6 -929,19 +931,19 @@@ pmt_equal(const pmt_t& x, const pmt_t& 
      return true;
    }
  
+   if (x->is_tuple() && y->is_tuple()){
+     pmt_tuple *xv = _tuple(x);
+     pmt_tuple *yv = _tuple(y);
+     if (xv->length() != yv->length())
+       return false;
+ 
+     for (unsigned i = 0; i < xv->length(); i++)
+       if (!pmt_equal(xv->_ref(i), yv->_ref(i)))
+       return false;
+ 
+     return true;
+   }
+ 
    if (x->is_uniform_vector() && y->is_uniform_vector()){
      pmt_uniform_vector *xv = _uniform_vector(x);
      pmt_uniform_vector *yv = _uniform_vector(y);
@@@ -759,11 -971,15 +973,15 @@@ pmt_length(const pmt_t& x
    if (x->is_uniform_vector())
      return _uniform_vector(x)->length();
  
-   if (x->is_null()) return 0;
+   if (x->is_tuple())
+     return _tuple(x)->length();
+ 
+   if (x->is_null())
+     return 0;
  
    if (x->is_pair()) {
      size_t length=1;
-       pmt_t it = pmt_cdr(x);
+     pmt_t it = pmt_cdr(x);
      while (pmt_is_pair(it)){
        length++;
        it = pmt_cdr(it);

diff --combined gruel/src/lib/pmt/pmt_int.h
index ba865b418979f51968e3280649d71433a15438f9,ed47249b12a5e192698f25a5e0b2f451d26abf47..7581845f825df373a65951c7d8241e8b60e1f5f9
--- 1/gruel/src/lib/pmt/pmt_int.h
--- 2/gruel/src/lib/pmt/pmt_int.h
+++ b/gruel/src/lib/pmt/pmt_int.h
@@@ -24,7 -24,6 +24,7 @@@
  
  #include <gruel/pmt.h>
  #include <boost/utility.hpp>
 +#include <boost/detail/atomic_count.hpp>
  
  /*
   * EVERYTHING IN THIS FILE IS PRIVATE TO THE IMPLEMENTATION!
@@@ -36,10 -35,8 +36,10 @@@
  namespace pmt {
  
  class pmt_base : boost::noncopyable {
 +  mutable boost::detail::atomic_count count_;
 +
  protected:
 -  pmt_base(){};
 +  pmt_base() : count_(0) {};
    virtual ~pmt_base();
  
  public:
@@@ -51,6 -48,7 +51,7 @@@
    virtual bool is_complex() const { return false; }
    virtual bool is_null()    const { return false; }
    virtual bool is_pair()    const { return false; }
+   virtual bool is_tuple()   const { return false; }
    virtual bool is_vector()  const { return false; }
    virtual bool is_dict()    const { return false; }
    virtual bool is_any()     const { return false; }
@@@ -69,9 -67,6 +70,9 @@@
    virtual bool is_c32vector() const { return false; }
    virtual bool is_c64vector() const { return false; }
  
 +  friend void intrusive_ptr_add_ref(pmt_base* p);
 +  friend void intrusive_ptr_release(pmt_base* p);
 +
  # if (PMT_LOCAL_ALLOCATOR)
    void *operator new(size_t);
    void operator delete(void *, size_t);
@@@ -186,6 -181,22 +187,22 @@@ public
    pmt_t _ref(size_t k) const { return d_v[k]; }
  };
  
+ class pmt_tuple : public pmt_base
+ {
+   std::vector<pmt_t>  d_v;
+ 
+ public:
+   pmt_tuple(size_t len);
+   //~pmt_tuple();
+ 
+   bool is_tuple() const { return true; }
+   pmt_t ref(size_t k) const;
+   size_t length() const { return d_v.size(); }
+ 
+   pmt_t _ref(size_t k) const { return d_v[k]; }
+   void _set(size_t k, pmt_t v) { d_v[k] = v; }
+ };
+ 
  class pmt_dict : public pmt_base
  {
    pmt_t               d_alist;        // list of (key . value) pairs