[Commit-gnuradio] r4491 - gnuradio/branches/developers/jcorgan/ticket-129/gnuradio-core/src/lib/runtime

[jcorgan]

Author: jcorgan
Date: 2007-02-17 07:17:52 -0700 (Sat, 17 Feb 2007)
New Revision: 4491

Modified:
   
gnuradio/branches/developers/jcorgan/ticket-129/gnuradio-core/src/lib/runtime/gr_simple_flowgraph.h
   
gnuradio/branches/developers/jcorgan/ticket-129/gnuradio-core/src/lib/runtime/gr_simple_flowgraph_detail.cc
   
gnuradio/branches/developers/jcorgan/ticket-129/gnuradio-core/src/lib/runtime/gr_simple_flowgraph_detail.h
Log:
Work in progress

Modified: 
gnuradio/branches/developers/jcorgan/ticket-129/gnuradio-core/src/lib/runtime/gr_simple_flowgraph.h
===================================================================
--- 
gnuradio/branches/developers/jcorgan/ticket-129/gnuradio-core/src/lib/runtime/gr_simple_flowgraph.h
 2007-02-16 02:41:27 UTC (rev 4490)
+++ 
gnuradio/branches/developers/jcorgan/ticket-129/gnuradio-core/src/lib/runtime/gr_simple_flowgraph.h
 2007-02-17 14:17:52 UTC (rev 4491)
@@ -1,6 +1,6 @@
 /* -*- c++ -*- */
 /*
- * Copyright 2006 Free Software Foundation, Inc.
+ * Copyright 2006,2007 Free Software Foundation, Inc.
  * 
  * This file is part of GNU Radio
  * 
@@ -31,22 +31,33 @@
 
 class gr_simple_flowgraph_detail;
 
+/*!
+ *\brief Class representing a low-level, "flattened" flow graph
+ *
+ * This class holds the results of the call to gr.hier_block2.flatten(),
+ * which is a graph that has only the connected blocks and edges of
+ * the original hier_block2, with all the hierarchy removed.
+ *
+ * While this class is exported to Python via SWIG for ease of QA
+ * testing, it is not used by application developers, and there is
+ * no way to feed this to a gr.runtime() instance.
+ */
 class gr_simple_flowgraph
 {
 private:
-    friend class gr_runtime_impl;
-    friend gr_simple_flowgraph_sptr gr_make_simple_flowgraph();
-    gr_simple_flowgraph();
+  friend class gr_runtime_impl;
+  friend gr_simple_flowgraph_sptr gr_make_simple_flowgraph();
+  gr_simple_flowgraph();
 
-    gr_simple_flowgraph_detail *d_detail;
+  gr_simple_flowgraph_detail *d_detail;
             
 public:
-    ~gr_simple_flowgraph();
+  ~gr_simple_flowgraph();
 
-    void define_component(const std::string &name, gr_block_sptr block);    
-    void connect(const std::string &src, int src_port, 
-                 const std::string &dst, int dst_port);
-    void validate();
+  void define_component(const std::string &name, gr_block_sptr block);    
+  void connect(const std::string &src, int src_port, 
+              const std::string &dst, int dst_port);
+  void validate();
 };
 
 #endif /* INCLUDED_GR_SIMPLE_FLOWGRAPH_H */

Modified: 
gnuradio/branches/developers/jcorgan/ticket-129/gnuradio-core/src/lib/runtime/gr_simple_flowgraph_detail.cc
===================================================================
--- 
gnuradio/branches/developers/jcorgan/ticket-129/gnuradio-core/src/lib/runtime/gr_simple_flowgraph_detail.cc
 2007-02-16 02:41:27 UTC (rev 4490)
+++ 
gnuradio/branches/developers/jcorgan/ticket-129/gnuradio-core/src/lib/runtime/gr_simple_flowgraph_detail.cc
 2007-02-17 14:17:52 UTC (rev 4491)
@@ -1,6 +1,6 @@
 /* -*- c++ -*- */
 /*
- * Copyright 2006 Free Software Foundation, Inc.
+ * Copyright 2006,2007 Free Software Foundation, Inc.
  *
  * This file is part of GNU Radio
  *
@@ -38,7 +38,7 @@
 gr_make_edge(const std::string &src_name, int src_port,
             const std::string &dst_name, int dst_port)
 {
-    return gr_edge_sptr(new gr_edge(src_name, src_port, dst_name, dst_port));
+  return gr_edge_sptr(new gr_edge(src_name, src_port, dst_name, dst_port));
 }
 
 gr_edge::gr_edge(const std::string &src_name, int src_port, const std::string 
&dst_name, int dst_port)
@@ -52,8 +52,8 @@
 }
 
 gr_simple_flowgraph_detail::gr_simple_flowgraph_detail() :
-d_components(),
-d_edges()
+  d_components(),
+  d_edges()
 {
 }
 
@@ -64,162 +64,162 @@
 void
 gr_simple_flowgraph_detail::reset()
 {
-    // Boost shared pointers will deallocate as needed
-    d_edges.clear();
-    d_components.clear();
+  // Boost shared pointers will deallocate as needed
+  d_edges.clear();
+  d_components.clear();
 }
 
 gr_block_sptr
 gr_simple_flowgraph_detail::lookup_block(const std::string &name)
 {
-    gr_component_miter_t p = d_components.find(name);
-    if (p != d_components.end())
-        return p->second;
-    else
-        return gr_block_sptr();
+  gr_component_miter_t p = d_components.find(name);
+  if (p != d_components.end())
+    return p->second;
+  else
+    return gr_block_sptr();
 }
 
 std::string
 gr_simple_flowgraph_detail::lookup_name(gr_block_sptr block)
 {
-    for (gr_component_miter_t p = d_components.begin(); p != 
d_components.end(); p++) {
-        if (p->second == block)
-            return p->first;
-    }
+  for (gr_component_miter_t p = d_components.begin(); p != d_components.end(); 
p++) {
+    if (p->second == block)
+      return p->first;
+  }
 
-    return std::string(""); // Not found
+  return std::string(""); // Not found
 }
 
 void
 gr_simple_flowgraph_detail::define_component(const std::string &name, 
gr_block_sptr block)
 {
-    if (!block)
-        throw std::invalid_argument("null block passed");
+  if (!block)
+    throw std::invalid_argument("null block passed");
 
-    if (!lookup_block(name))
-        d_components[name] = block;
-    else
-        throw std::invalid_argument("name already in use");
+  if (!lookup_block(name))
+    d_components[name] = block;
+  else
+    throw std::invalid_argument("name already in use");
 }
 
 void
 gr_simple_flowgraph_detail::connect(const std::string &src_name, int src_port,
                                     const std::string &dst_name, int dst_port)
 {
-    gr_block_sptr src_block = lookup_block(src_name);
-    gr_block_sptr dst_block = lookup_block(dst_name);
+  gr_block_sptr src_block = lookup_block(src_name);
+  gr_block_sptr dst_block = lookup_block(dst_name);
 
-    if (GR_SIMPLE_FLOWGRAPH_DETAIL_DEBUG)
-        std::cout << "Connecting " << src_name << ":" << src_port << "->"
-                  << dst_name << ":" << dst_port << std::endl;
+  if (GR_SIMPLE_FLOWGRAPH_DETAIL_DEBUG)
+    std::cout << "Connecting " << src_name << ":" << src_port << "->"
+             << dst_name << ":" << dst_port << std::endl;
 
-    if (!src_block)
-        throw std::invalid_argument("unknown src name");
-    if (!dst_block)
-        throw std::invalid_argument("unknown dst name");
+  if (!src_block)
+    throw std::invalid_argument("unknown src name");
+  if (!dst_block)
+    throw std::invalid_argument("unknown dst name");
 
-    check_valid_port(src_block->output_signature(), src_port);
-    check_valid_port(dst_block->input_signature(), dst_port);
-    check_dst_not_used(dst_name, dst_port);
-    check_type_match(src_block, src_port, dst_block, dst_port);
+  check_valid_port(src_block->output_signature(), src_port);
+  check_valid_port(dst_block->input_signature(), dst_port);
+  check_dst_not_used(dst_name, dst_port);
+  check_type_match(src_block, src_port, dst_block, dst_port);
 
-    d_edges.push_back(gr_make_edge(src_name, src_port, dst_name, dst_port));
+  d_edges.push_back(gr_make_edge(src_name, src_port, dst_name, dst_port));
 }
 
 void
 gr_simple_flowgraph_detail::check_valid_port(gr_io_signature_sptr sig, int 
port)
 {
-    if (port < 0)
-        throw std::invalid_argument("negative port number");
-    if (sig->max_streams() >= 0 && port >= sig->max_streams())
-        throw std::invalid_argument("port number exceeds max");
+  if (port < 0)
+    throw std::invalid_argument("negative port number");
+  if (sig->max_streams() >= 0 && port >= sig->max_streams())
+    throw std::invalid_argument("port number exceeds max");
 }
 
 void
 gr_simple_flowgraph_detail::check_dst_not_used(const std::string &name, int 
port)
 {
-    for (gr_edge_viter_t p = d_edges.begin(); p != d_edges.end(); p++)
-       if ((*p)->dst_name() == name && (*p)->dst_port() == port)
-           throw std::invalid_argument("dst already in use");
+  for (gr_edge_viter_t p = d_edges.begin(); p != d_edges.end(); p++)
+    if ((*p)->dst_name() == name && (*p)->dst_port() == port)
+      throw std::invalid_argument("dst already in use");
 }
 
 void
 gr_simple_flowgraph_detail::check_type_match(gr_block_sptr src_block, int 
src_port,
                                              gr_block_sptr dst_block, int 
dst_port)
 {
-    int src_size = src_block->output_signature()->sizeof_stream_item(src_port);
-    int dst_size = dst_block->input_signature()->sizeof_stream_item(dst_port);
+  int src_size = src_block->output_signature()->sizeof_stream_item(src_port);
+  int dst_size = dst_block->input_signature()->sizeof_stream_item(dst_port);
 
-    if (src_size != dst_size)
-        throw std::invalid_argument("type size mismatch");
+  if (src_size != dst_size)
+    throw std::invalid_argument("type size mismatch");
 }
 
 void
 gr_simple_flowgraph_detail::validate()
 {
-    for (gr_component_miter_t p = d_components.begin(); p != 
d_components.end(); p++) {
-       std::vector<int> used_ports;
-       int ninputs, noutputs;
+  for (gr_component_miter_t p = d_components.begin(); p != d_components.end(); 
p++) {
+    std::vector<int> used_ports;
+    int ninputs, noutputs;
 
-        used_ports = calc_used_ports(p->first, true); // inputs
-       ninputs = used_ports.size();
-       check_contiguity(p->second, used_ports, true); // inputs
+    used_ports = calc_used_ports(p->first, true); // inputs
+    ninputs = used_ports.size();
+    check_contiguity(p->second, used_ports, true); // inputs
 
-       used_ports = calc_used_ports(p->first, false); // outputs
-       noutputs = used_ports.size();
-       check_contiguity(p->second, used_ports, false); // outputs
+    used_ports = calc_used_ports(p->first, false); // outputs
+    noutputs = used_ports.size();
+    check_contiguity(p->second, used_ports, false); // outputs
 
-       if (!(p->second->check_topology(ninputs, noutputs)))
-           throw std::runtime_error("check topology failed");
-    }
+    if (!(p->second->check_topology(ninputs, noutputs)))
+      throw std::runtime_error("check topology failed");
+  }
 }
 
 std::vector<int>
 gr_simple_flowgraph_detail::calc_used_ports(const std::string &name, bool 
check_inputs)
 {
-    if (GR_SIMPLE_FLOWGRAPH_DETAIL_DEBUG)
-        std::cout << "Calculating used " << (check_inputs ? "input " : "output 
")
-                  << "ports...";
+  if (GR_SIMPLE_FLOWGRAPH_DETAIL_DEBUG)
+    std::cout << "Calculating used " << (check_inputs ? "input " : "output ")
+             << "ports...";
 
-    std::vector<int> tmp, result;
-    std::insert_iterator<std::vector<int> > inserter(result, result.begin());
+  std::vector<int> tmp, result;
+  std::insert_iterator<std::vector<int> > inserter(result, result.begin());
 
-    gr_edge_vector_t edges = calc_connections(name, check_inputs);
+  gr_edge_vector_t edges = calc_connections(name, check_inputs);
 
-    for (gr_edge_viter_t p = edges.begin(); p != edges.end(); p++) {
-        if (check_inputs == true)
-            tmp.push_back((*p)->dst_port());
-        else
-            tmp.push_back((*p)->src_port());
-    }
+  for (gr_edge_viter_t p = edges.begin(); p != edges.end(); p++) {
+    if (check_inputs == true)
+      tmp.push_back((*p)->dst_port());
+    else
+      tmp.push_back((*p)->src_port());
+  }
 
-    // remove duplicates
-    std::sort(tmp.begin(), tmp.end());
-    std::unique_copy(tmp.begin(), tmp.end(), inserter);
+  // remove duplicates
+  std::sort(tmp.begin(), tmp.end());
+  std::unique_copy(tmp.begin(), tmp.end(), inserter);
 
-    if (GR_SIMPLE_FLOWGRAPH_DETAIL_DEBUG)
-        std::cout << result.size() << std::endl;
+  if (GR_SIMPLE_FLOWGRAPH_DETAIL_DEBUG)
+    std::cout << result.size() << std::endl;
 
-    return result;
+  return result;
 }
 
 gr_edge_vector_t
 gr_simple_flowgraph_detail::calc_connections(const std::string &name, bool 
check_inputs)
 {
-    gr_edge_vector_t result;
+  gr_edge_vector_t result;
 
-    for (gr_edge_viter_t p = d_edges.begin(); p != d_edges.end(); p++) {
-        if (check_inputs) {
-            if ((*p)->dst_name() == name)
-                result.push_back(*p);
-        }
-        else {
-            if ((*p)->src_name() == name)
-                result.push_back(*p);
-        }
+  for (gr_edge_viter_t p = d_edges.begin(); p != d_edges.end(); p++) {
+    if (check_inputs) {
+      if ((*p)->dst_name() == name)
+       result.push_back(*p);
     }
+    else {
+      if ((*p)->src_name() == name)
+       result.push_back(*p);
+    }
+  }
 
-    return result;    // assumes no duplicates
+  return result;    // assumes no duplicates
 }
 
 void
@@ -227,335 +227,340 @@
                                              const std::vector<int> 
&used_ports,
                                              bool check_inputs)
 {
-    if (GR_SIMPLE_FLOWGRAPH_DETAIL_DEBUG)
-        std::cout << "Checking " << (check_inputs ? "input " : "output ")
-                  << "contiguity...";
+  if (GR_SIMPLE_FLOWGRAPH_DETAIL_DEBUG)
+    std::cout << "Checking " << (check_inputs ? "input " : "output ")
+             << "contiguity...";
 
-    gr_io_signature_sptr sig =
-        check_inputs ? block->input_signature() : block->output_signature();
+  gr_io_signature_sptr sig =
+    check_inputs ? block->input_signature() : block->output_signature();
 
-    int nports = used_ports.size();
-    int min_ports = sig->min_streams();
+  int nports = used_ports.size();
+  int min_ports = sig->min_streams();
 
-    if (nports == 0) {
-        if (min_ports == 0) {
-            if (GR_SIMPLE_FLOWGRAPH_DETAIL_DEBUG)
-                std::cout << "ok." << std::endl;
-            return;
-        }
-        else {
-            if (GR_SIMPLE_FLOWGRAPH_DETAIL_DEBUG)
-                std::cout << "needs " << min_ports << ", only has "
-                          << nports << std::endl;
+  if (nports == 0) {
+    if (min_ports == 0) {
+      if (GR_SIMPLE_FLOWGRAPH_DETAIL_DEBUG)
+       std::cout << "ok." << std::endl;
+      return;
+    }
+    else {
+      if (GR_SIMPLE_FLOWGRAPH_DETAIL_DEBUG)
+       std::cout << "needs " << min_ports << ", only has "
+                 << nports << std::endl;
 
-            throw std::runtime_error("insufficient ports");
-        }
+      throw std::runtime_error("insufficient ports");
     }
+  }
 
-    if (used_ports[nports-1]+1 != nports) {
-        for (int i = 0; i < nports; i++) {
-            if (used_ports[i] != i) {
-                if (GR_SIMPLE_FLOWGRAPH_DETAIL_DEBUG)
-                       std::cout << "missing " << (check_inputs ? "input 
":"output ")
-                              << i << std::endl;
+  if (used_ports[nports-1]+1 != nports) {
+    for (int i = 0; i < nports; i++) {
+      if (used_ports[i] != i) {
+       if (GR_SIMPLE_FLOWGRAPH_DETAIL_DEBUG)
+         std::cout << "missing " << (check_inputs ? "input ":"output ")
+                   << i << std::endl;
 
-                throw std::runtime_error("missing input assignment");
-               }
-           }
+       throw std::runtime_error("missing input assignment");
+      }
     }
+  }
 
-    if (GR_SIMPLE_FLOWGRAPH_DETAIL_DEBUG)
-        std::cout << "ok." << std::endl;
+  if (GR_SIMPLE_FLOWGRAPH_DETAIL_DEBUG)
+    std::cout << "ok." << std::endl;
 }
 
 void
 gr_simple_flowgraph_detail::setup_connections()
 {
-    // Assign block details to component blocks
-    for (gr_component_miter_t p = d_components.begin(); p != 
d_components.end(); p++) {
-        if (GR_SIMPLE_FLOWGRAPH_DETAIL_DEBUG)
-            std::cout << "Allocating output buffers for " << p->first << "..." 
<< std::endl;
+  // Assign block details to component blocks
+  for (gr_component_miter_t p = d_components.begin(); p != d_components.end(); 
p++) {
+    if (GR_SIMPLE_FLOWGRAPH_DETAIL_DEBUG)
+      std::cout << "Allocating output buffers for " << p->first << "..." << 
std::endl;
 
-        int ninputs = calc_used_ports(p->first, true).size();
-        int noutputs = calc_used_ports(p->first, false).size();
-        gr_block_detail_sptr detail = gr_make_block_detail(ninputs, noutputs);
-        for (int i = 0; i < noutputs; i++)
-            detail->set_output(i, allocate_buffer(p->first, i));
-        p->second->set_detail(detail);
-    }
+    int ninputs = calc_used_ports(p->first, true).size();
+    int noutputs = calc_used_ports(p->first, false).size();
+    gr_block_detail_sptr detail = gr_make_block_detail(ninputs, noutputs);
+    for (int i = 0; i < noutputs; i++)
+      detail->set_output(i, allocate_buffer(p->first, i));
+    p->second->set_detail(detail);
+  }
 
-    // Connect inputs to outputs for each block
-    for(gr_component_miter_t p = d_components.begin(); p != 
d_components.end(); p++) {
-        // Get its detail and edges that feed into it
-        gr_block_detail_sptr detail = p->second->detail();
-        gr_edge_vector_t in_edges = calc_upstream_edges(p->first);
+  // Connect inputs to outputs for each block
+  for(gr_component_miter_t p = d_components.begin(); p != d_components.end(); 
p++) {
+    // Get its detail and edges that feed into it
+    gr_block_detail_sptr detail = p->second->detail();
+    gr_edge_vector_t in_edges = calc_upstream_edges(p->first);
 
-        if (GR_SIMPLE_FLOWGRAPH_DETAIL_DEBUG)
-               if (in_edges.size() > 0)
-                   std::cout << "Connecting inputs to " << p->first << "..." 
<< std::endl;
+    if (GR_SIMPLE_FLOWGRAPH_DETAIL_DEBUG)
+      if (in_edges.size() > 0)
+       std::cout << "Connecting inputs to " << p->first << "..." << std::endl;
 
-        // For each edge that feeds into it
-        for (gr_edge_viter_t e = in_edges.begin(); e != in_edges.end(); e++) {
-            // Set the input buffer on the destination port to the output
-            // buffer on the source port
-            int dst_port = (*e)->dst_port();
-            int src_port = (*e)->src_port();
-            gr_block_sptr src_block = lookup_block((*e)->src_name());
-            gr_buffer_sptr src_buffer = src_block->detail()->output(src_port);
+    // For each edge that feeds into it
+    for (gr_edge_viter_t e = in_edges.begin(); e != in_edges.end(); e++) {
+      // Set the input reader on the destination port to the output
+      // buffer on the source port
+      int dst_port = (*e)->dst_port();
+      int src_port = (*e)->src_port();
+      gr_block_sptr src_block = lookup_block((*e)->src_name());
+      gr_buffer_sptr src_buffer = src_block->detail()->output(src_port);
 
-            if (GR_SIMPLE_FLOWGRAPH_DETAIL_DEBUG)
-                std::cout << "Setting input on " << (*e)->dst_name()
-                          << ":" << dst_port << std::endl;
+      if (GR_SIMPLE_FLOWGRAPH_DETAIL_DEBUG)
+       std::cout << "Setting input on " << (*e)->dst_name()
+                 << ":" << dst_port << std::endl;
 
-            detail->set_input(dst_port, gr_buffer_add_reader(src_buffer, 
p->second->history()-1));
-        }
+      detail->set_input(dst_port, gr_buffer_add_reader(src_buffer, 
p->second->history()-1));
     }
+  }
 }
 
 gr_buffer_sptr
 gr_simple_flowgraph_detail::allocate_buffer(const std::string &name, int port)
 {
-    gr_block_sptr block = lookup_block(name);
-    int item_size = block->output_signature()->sizeof_stream_item(port);
-    int nitems = s_fixed_buffer_size/item_size;
+  gr_block_sptr block = lookup_block(name);
+  int item_size = block->output_signature()->sizeof_stream_item(port);
+  int nitems = s_fixed_buffer_size/item_size;
 
-    // Make sure there are at least twice the output_multiple no. of items
-    if (nitems < 2*block->output_multiple())   // Note: this means 
output_multiple()
-        nitems = 2*block->output_multiple();   // can't be changed by block 
dynamically
+  // Make sure there are at least twice the output_multiple no. of items
+  if (nitems < 2*block->output_multiple())     // Note: this means 
output_multiple()
+    nitems = 2*block->output_multiple();       // can't be changed by block 
dynamically
 
-    // If any downstream blocks are decimators and/or have a large 
output_multiple,
-    // ensure we have a buffer at least twice their decimation 
factor*output_multiple
-    gr_block_vector_t blocks = calc_downstream_blocks(name, port);
-    for (gr_block_viter_t p = blocks.begin(); p != blocks.end(); p++) {
-        int decimation = (int)(1.0/(*p)->relative_rate());
-        int multiple   = (*p)->output_multiple();
-        int history    = (*p)->history();
-        nitems = std::max(nitems, 2*(decimation*multiple+history));
-    }
+  // If any downstream blocks are decimators and/or have a large 
output_multiple,
+  // ensure we have a buffer at least twice their decimation 
factor*output_multiple
+  gr_block_vector_t blocks = calc_downstream_blocks(name, port);
+  for (gr_block_viter_t p = blocks.begin(); p != blocks.end(); p++) {
+    int decimation = (int)(1.0/(*p)->relative_rate());
+    int multiple   = (*p)->output_multiple();
+    int history    = (*p)->history();
+    nitems = std::max(nitems, 2*(decimation*multiple+history));
+  }
 
-    if (GR_SIMPLE_FLOWGRAPH_DETAIL_DEBUG)
-        std::cout << "Allocating buffer for port " << port << " with "
-                  << nitems << " items of size " << item_size << std::endl;
+  if (GR_SIMPLE_FLOWGRAPH_DETAIL_DEBUG)
+    std::cout << "Allocating buffer for port " << port << " with "
+             << nitems << " items of size " << item_size << std::endl;
 
-    return gr_make_buffer(nitems, item_size);
+  return gr_make_buffer(nitems, item_size);
 }
 
 gr_block_vector_t
 gr_simple_flowgraph_detail::calc_downstream_blocks(const std::string &name, 
int port)
 {
-    gr_block_vector_t tmp, result;
-    std::insert_iterator<gr_block_vector_t> inserter(result, result.begin());
+  gr_block_vector_t tmp, result;
+  std::insert_iterator<gr_block_vector_t> inserter(result, result.begin());
 
-    for (gr_edge_viter_t p = d_edges.begin(); p != d_edges.end(); p++)
-        if ((*p)->src_name() == name && (*p)->src_port() == port)
-            tmp.push_back(lookup_block((*p)->dst_name()));
+  for (gr_edge_viter_t p = d_edges.begin(); p != d_edges.end(); p++)
+    if ((*p)->src_name() == name && (*p)->src_port() == port)
+      tmp.push_back(lookup_block((*p)->dst_name()));
 
-    // Remove duplicates
-    sort(tmp.begin(), tmp.end());
-    unique_copy(tmp.begin(), tmp.end(), inserter);
-    return result;
+  // Remove duplicates
+  sort(tmp.begin(), tmp.end());
+  unique_copy(tmp.begin(), tmp.end(), inserter);
+  return result;
 }
 
 gr_block_vector_t
 gr_simple_flowgraph_detail::calc_downstream_blocks(const std::string &name)
 {
-    gr_block_vector_t tmp, result;
-    std::insert_iterator<gr_block_vector_t> inserter(result, result.begin());
+  gr_block_vector_t tmp, result;
+  std::insert_iterator<gr_block_vector_t> inserter(result, result.begin());
 
-    for (gr_edge_viter_t p = d_edges.begin(); p != d_edges.end(); p++)
-        if ((*p)->src_name() == name)
-            tmp.push_back(lookup_block((*p)->dst_name()));
+  for (gr_edge_viter_t p = d_edges.begin(); p != d_edges.end(); p++)
+    if ((*p)->src_name() == name)
+      tmp.push_back(lookup_block((*p)->dst_name()));
 
-    // Remove duplicates
-    sort(tmp.begin(), tmp.end());
-    unique_copy(tmp.begin(), tmp.end(), inserter);
-    return result;
+  // Remove duplicates
+  sort(tmp.begin(), tmp.end());
+  unique_copy(tmp.begin(), tmp.end(), inserter);
+  return result;
 }
 
 gr_edge_vector_t
 gr_simple_flowgraph_detail::calc_upstream_edges(const std::string &name)
 {
-    gr_edge_vector_t result;
+  gr_edge_vector_t result;
 
-    for (gr_edge_viter_t p = d_edges.begin(); p != d_edges.end(); p++)
-        if ((*p)->dst_name() == name)
-            result.push_back(*p);
+  for (gr_edge_viter_t p = d_edges.begin(); p != d_edges.end(); p++)
+    if ((*p)->dst_name() == name)
+      result.push_back(*p);
 
-    return result; // Assume no duplicates
+  return result; // Assume no duplicates
 }
 
 gr_block_vector_t
 gr_simple_flowgraph_detail::calc_used_blocks()
 {
-    std::vector<std::string> tmp, tmp_unique;
-    std::insert_iterator<std::vector<std::string> > inserter(tmp_unique, 
tmp_unique.begin());
-    gr_block_vector_t result;
+  std::vector<std::string> tmp, tmp_unique;
+  std::insert_iterator<std::vector<std::string> > inserter(tmp_unique, 
tmp_unique.begin());
+  gr_block_vector_t result;
 
-    for (gr_edge_viter_t p = d_edges.begin(); p != d_edges.end(); p++) {
-        tmp.push_back((*p)->src_name());
-        tmp.push_back((*p)->dst_name());
-    }
+  for (gr_edge_viter_t p = d_edges.begin(); p != d_edges.end(); p++) {
+    tmp.push_back((*p)->src_name());
+    tmp.push_back((*p)->dst_name());
+  }
 
-    sort(tmp.begin(), tmp.end());
-    unique_copy(tmp.begin(), tmp.end(), inserter);
+  sort(tmp.begin(), tmp.end());
+  unique_copy(tmp.begin(), tmp.end(), inserter);
 
-    for (std::vector<std::string>::iterator p = tmp_unique.begin();
-         p != tmp_unique.end(); p++)
-        result.push_back(lookup_block(*p));
+  for (std::vector<std::string>::iterator p = tmp_unique.begin();
+       p != tmp_unique.end(); p++)
+    result.push_back(lookup_block(*p));
 
-    if (GR_SIMPLE_FLOWGRAPH_DETAIL_DEBUG)
-        std::cout << "Flowgraph uses " << result.size()
-                  << " distinct blocks." << std::endl;
+  if (GR_SIMPLE_FLOWGRAPH_DETAIL_DEBUG)
+    std::cout << "Flowgraph uses " << result.size()
+             << " distinct blocks." << std::endl;
 
-    return result;
+  return result;
 }
 
 std::vector<gr_block_vector_t>
 gr_simple_flowgraph_detail::partition()
 {
-    std::vector<gr_block_vector_t> result;
-    gr_block_vector_t blocks = calc_used_blocks();
-    gr_block_vector_t graph;
+  std::vector<gr_block_vector_t> result;
+  gr_block_vector_t blocks = calc_used_blocks();
+  gr_block_vector_t graph;
 
-    while (blocks.size() > 0) {
-        graph = calc_reachable_blocks(blocks[0], blocks);
-        assert(graph.size());
-        result.push_back(topological_sort(graph));
+  while (blocks.size() > 0) {
+    graph = calc_reachable_blocks(blocks[0], blocks);
+    assert(graph.size());
+    result.push_back(topological_sort(graph));
 
-        for (gr_block_viter_t p = graph.begin(); p != graph.end(); p++)
-            blocks.erase(find(blocks.begin(), blocks.end(), *p));
-    }
+    for (gr_block_viter_t p = graph.begin(); p != graph.end(); p++)
+      blocks.erase(find(blocks.begin(), blocks.end(), *p));
+  }
 
-    return result;
+  return result;
 }
 
 gr_block_vector_t
 gr_simple_flowgraph_detail::calc_reachable_blocks(gr_block_sptr block, 
gr_block_vector_t &blocks)
 {
-    gr_block_vector_t result;
+  gr_block_vector_t result;
 
-    // Mark all blocks as unvisited
-    for (gr_block_viter_t p = blocks.begin(); p != blocks.end(); p++)
-        (*p)->detail()->set_color(gr_block_detail::WHITE);
+  // Mark all blocks as unvisited
+  for (gr_block_viter_t p = blocks.begin(); p != blocks.end(); p++)
+    (*p)->detail()->set_color(gr_block_detail::WHITE);
 
-    // Recursively mark all reachable blocks
-    reachable_dfs_visit(block, blocks);
+  // Recursively mark all reachable blocks
+  reachable_dfs_visit(block, blocks);
 
-    // Collect all the blocks that have been visited
-    for (gr_block_viter_t p = blocks.begin(); p != blocks.end(); p++)
-        if ((*p)->detail()->color() == gr_block_detail::BLACK)
-            result.push_back(*p);
+  // Collect all the blocks that have been visited
+  for (gr_block_viter_t p = blocks.begin(); p != blocks.end(); p++)
+    if ((*p)->detail()->color() == gr_block_detail::BLACK)
+      result.push_back(*p);
 
-    return result;
+  return result;
 }
 
 // Recursively mark all reachable blocks from given block and block list
 void 
 gr_simple_flowgraph_detail::reachable_dfs_visit(gr_block_sptr block, 
gr_block_vector_t &blocks)
 {
-    // Mark the current one as visited
-    block->detail()->set_color(gr_block_detail::BLACK);
+  // Mark the current one as visited
+  block->detail()->set_color(gr_block_detail::BLACK);
 
-    // Recurse into adjacent vertices
-    gr_block_vector_t adjacent = calc_adjacent_blocks(block, blocks);
+  // Recurse into adjacent vertices
+  gr_block_vector_t adjacent = calc_adjacent_blocks(block, blocks);
 
-    for (gr_block_viter_t p = adjacent.begin(); p != adjacent.end(); p++)
-        if ((*p)->detail()->color() == gr_block_detail::WHITE)
-               reachable_dfs_visit(*p, blocks);
+  for (gr_block_viter_t p = adjacent.begin(); p != adjacent.end(); p++)
+    if ((*p)->detail()->color() == gr_block_detail::WHITE)
+      reachable_dfs_visit(*p, blocks);
 }
 
 // Return a list of block adjacent to a given block along any edge
 gr_block_vector_t 
 gr_simple_flowgraph_detail::calc_adjacent_blocks(gr_block_sptr block, 
gr_block_vector_t &blocks)
 {
-    gr_block_vector_t tmp, result;
-    std::insert_iterator<gr_block_vector_t> inserter(result, result.begin());
+  gr_block_vector_t tmp, result;
+  std::insert_iterator<gr_block_vector_t> inserter(result, result.begin());
     
-    // Find any blocks that are inputs or outputs
-    for (gr_edge_viter_t p = d_edges.begin(); p != d_edges.end(); p++) {
-        if (lookup_block((*p)->src_name()) == block)
-            tmp.push_back(lookup_block((*p)->dst_name()));
-        if (lookup_block((*p)->dst_name()) == block)
-            tmp.push_back(lookup_block((*p)->src_name()));
-    }    
+  // Find any blocks that are inputs or outputs
+  for (gr_edge_viter_t p = d_edges.begin(); p != d_edges.end(); p++) {
+    if (lookup_block((*p)->src_name()) == block)
+      tmp.push_back(lookup_block((*p)->dst_name()));
+    if (lookup_block((*p)->dst_name()) == block)
+      tmp.push_back(lookup_block((*p)->src_name()));
+  }    
 
-    // Remove duplicates
-    sort(tmp.begin(), tmp.end());
-    unique_copy(tmp.begin(), tmp.end(), inserter);
-    return result;
+  // Remove duplicates
+  sort(tmp.begin(), tmp.end());
+  unique_copy(tmp.begin(), tmp.end(), inserter);
+  return result;
 }
 
 gr_block_vector_t
 gr_simple_flowgraph_detail::topological_sort(gr_block_vector_t &blocks)
 {
-    gr_block_vector_t result, tmp;
-    tmp = sort_sources_first(blocks);
+  gr_block_vector_t result, tmp;
+  tmp = sort_sources_first(blocks);
 
-    // Start 'em all white
-    for (gr_block_viter_t p = tmp.begin(); p != tmp.end(); p++)
-        (*p)->detail()->set_color(gr_block_detail::WHITE);
+  // Start 'em all white
+  for (gr_block_viter_t p = tmp.begin(); p != tmp.end(); p++)
+    (*p)->detail()->set_color(gr_block_detail::WHITE);
 
-    for (gr_block_viter_t p = tmp.begin(); p != tmp.end(); p++) {
-        if ((*p)->detail()->color() == gr_block_detail::WHITE)
-            topological_dfs_visit(*p, result);
-    }    
+  for (gr_block_viter_t p = tmp.begin(); p != tmp.end(); p++) {
+    if ((*p)->detail()->color() == gr_block_detail::WHITE)
+      topological_dfs_visit(*p, result);
+  }    
 
-    reverse(result.begin(), result.end());
+  reverse(result.begin(), result.end());
 
-    return result;
+  return result;
 }
 
 bool
 gr_simple_flowgraph_detail::source_p(gr_block_sptr block)
 {
-    return (calc_upstream_edges(lookup_name(block)).size() == 0);
+  return (calc_upstream_edges(lookup_name(block)).size() == 0);
 }
 
 gr_block_vector_t
 gr_simple_flowgraph_detail::sort_sources_first(gr_block_vector_t &blocks)
 {
-    gr_block_vector_t sources, nonsources, result;
+  gr_block_vector_t sources, nonsources, result;
 
-    for (gr_block_viter_t p = blocks.begin(); p != blocks.end(); p++) {
-        if (source_p(*p))
-            sources.push_back(*p);
-        else
-            nonsources.push_back(*p);
-    }
+  for (gr_block_viter_t p = blocks.begin(); p != blocks.end(); p++) {
+    if (source_p(*p))
+      sources.push_back(*p);
+    else
+      nonsources.push_back(*p);
+  }
 
-    for (gr_block_viter_t p = sources.begin(); p != sources.end(); p++)
-        result.push_back(*p);
+  for (gr_block_viter_t p = sources.begin(); p != sources.end(); p++)
+    result.push_back(*p);
 
-    for (gr_block_viter_t p = nonsources.begin(); p != nonsources.end(); p++)
-        result.push_back(*p);
+  for (gr_block_viter_t p = nonsources.begin(); p != nonsources.end(); p++)
+    result.push_back(*p);
 
-    return result;
+  return result;
 }
 
 void
 gr_simple_flowgraph_detail::topological_dfs_visit(gr_block_sptr block, 
gr_block_vector_t &output)
 {
-    block->detail()->set_color(gr_block_detail::GREY);
+  block->detail()->set_color(gr_block_detail::GREY);
 
-    gr_block_vector_t blocks(calc_downstream_blocks(lookup_name(block)));
+  gr_block_vector_t blocks(calc_downstream_blocks(lookup_name(block)));
 
-    for (gr_block_viter_t p = blocks.begin(); p != blocks.end(); p++) {
-        switch ((*p)->detail()->color()) {
-            case gr_block_detail::WHITE:           
-                topological_dfs_visit(*p, output);
-                break;
+  for (gr_block_viter_t p = blocks.begin(); p != blocks.end(); p++) {
+    switch ((*p)->detail()->color()) {
+    case gr_block_detail::WHITE:           
+      topological_dfs_visit(*p, output);
+      break;
 
-            case gr_block_detail::GREY:            
-                throw std::runtime_error("flow graph has loops!");
+    case gr_block_detail::GREY:            
+      throw std::runtime_error("flow graph has loops!");
 
-            case gr_block_detail::BLACK:
-                continue;
+    case gr_block_detail::BLACK:
+      continue;
 
-            default:
-                throw std::runtime_error("invalid color on block!");
-        }
+    default:
+      throw std::runtime_error("invalid color on block!");
     }
+  }
 
-    block->detail()->set_color(gr_block_detail::BLACK);
-    output.push_back(block);
+  block->detail()->set_color(gr_block_detail::BLACK);
+  output.push_back(block);
 }
+
+void
+gr_simple_flowgraph_detail::merge_connections(gr_simple_flowgraph_sptr sfg)
+{
+}

Modified: 
gnuradio/branches/developers/jcorgan/ticket-129/gnuradio-core/src/lib/runtime/gr_simple_flowgraph_detail.h
===================================================================
--- 
gnuradio/branches/developers/jcorgan/ticket-129/gnuradio-core/src/lib/runtime/gr_simple_flowgraph_detail.h
  2007-02-16 02:41:27 UTC (rev 4490)
+++ 
gnuradio/branches/developers/jcorgan/ticket-129/gnuradio-core/src/lib/runtime/gr_simple_flowgraph_detail.h
  2007-02-17 14:17:52 UTC (rev 4491)
@@ -1,6 +1,6 @@
 /* -*- c++ -*- */
 /*
- * Copyright 2006 Free Software Foundation, Inc.
+ * Copyright 2006,2007 Free Software Foundation, Inc.
  * 
  * This file is part of GNU Radio
  * 
@@ -34,13 +34,13 @@
 class gr_endpoint
 {
 private:
-    std::string d_name;
-    int d_port;
+  std::string d_name;
+  int d_port;
 
 public:
-    gr_endpoint(const std::string &name, int port) { d_name = name; d_port = 
port; }
-    const std::string &name() const { return d_name; }
-    int port() const { return d_port; }
+  gr_endpoint(const std::string &name, int port) { d_name = name; d_port = 
port; }
+  const std::string &name() const { return d_name; }
+  int port() const { return d_port; }
 };    
 
 class gr_edge;
@@ -51,20 +51,20 @@
 class gr_edge
 {
 private:
-    friend gr_edge_sptr gr_make_edge(const std::string &src_name, int src_port,
-                                     const std::string &dst_name, int 
dst_port);
-    gr_edge(const std::string &name, int src_port,
-            const std::string &name, int dst_port);
+  friend gr_edge_sptr gr_make_edge(const std::string &src_name, int src_port,
+                                  const std::string &dst_name, int dst_port);
+  gr_edge(const std::string &name, int src_port,
+         const std::string &name, int dst_port);
 
-    gr_endpoint d_src;
-    gr_endpoint d_dst;
+  gr_endpoint d_src;
+  gr_endpoint d_dst;
 
 public:
-    ~gr_edge();
-    const std::string src_name() const { return d_src.name(); }
-    const std::string dst_name() const { return d_dst.name(); }
-    int src_port() const { return d_src.port(); }
-    int dst_port() const { return d_dst.port(); }
+  ~gr_edge();
+  const std::string src_name() const { return d_src.name(); }
+  const std::string dst_name() const { return d_dst.name(); }
+  int src_port() const { return d_src.port(); }
+  int dst_port() const { return d_dst.port(); }
 };
 
 typedef std::vector<gr_edge_sptr> gr_edge_vector_t;
@@ -73,63 +73,65 @@
 class gr_simple_flowgraph_detail
 {
 private:
-    friend class gr_simple_flowgraph;
-    friend class gr_runtime_impl;
-    friend class topo_block_cmp;
+  friend class gr_simple_flowgraph;
+  friend class gr_runtime_impl;
+  friend class topo_block_cmp;
     
-    gr_simple_flowgraph_detail();
+  gr_simple_flowgraph_detail();
 
-    gr_component_map_t d_components;
-    gr_edge_vector_t   d_edges;
-    static const unsigned int s_fixed_buffer_size = GR_FIXED_BUFFER_SIZE;
+  gr_component_map_t d_components;
+  gr_edge_vector_t   d_edges;
+  static const unsigned int s_fixed_buffer_size = GR_FIXED_BUFFER_SIZE;
     
-    void reset();
-    void define_component(const std::string &name, gr_block_sptr block);    
-    void connect(const std::string &src, int src_port, 
-                 const std::string &dst, int dst_port);
-    gr_block_sptr lookup_block(const std::string &name);
-    std::string lookup_name(const gr_block_sptr block);
+  void reset();
+  void define_component(const std::string &name, gr_block_sptr block);    
+  void connect(const std::string &src, int src_port, 
+              const std::string &dst, int dst_port);
+  gr_block_sptr lookup_block(const std::string &name);
+  std::string lookup_name(const gr_block_sptr block);
 
-    void check_valid_port(gr_io_signature_sptr sig, int port);
-    void check_dst_not_used(const std::string &name, int port);
-    void check_type_match(gr_block_sptr src_block, int src_port,
-                          gr_block_sptr dst_block, int dst_port);
-    void validate();
-    gr_edge_vector_t calc_connections(const std::string &name, bool 
check_inputs); // false=use outputs
-    std::vector<int> calc_used_ports(const std::string &name, bool 
check_inputs); 
-    void check_contiguity(gr_block_sptr block, const std::vector<int> 
&used_ports, 
-                          bool check_inputs);
-    void setup_connections();
-    gr_buffer_sptr allocate_buffer(const std::string &name, int port);
-    gr_block_vector_t calc_downstream_blocks(const std::string &name, int 
port);
-    gr_block_vector_t calc_downstream_blocks(const std::string &name);
-    gr_edge_vector_t calc_upstream_edges(const std::string &name);
-    gr_block_vector_t calc_used_blocks();
-    std::vector<gr_block_vector_t> partition();
-    gr_block_vector_t calc_reachable_blocks(gr_block_sptr block, 
gr_block_vector_t &blocks);
-    gr_block_vector_t topological_sort(gr_block_vector_t &blocks);
-    void reachable_dfs_visit(gr_block_sptr block, gr_block_vector_t &blocks);
-    gr_block_vector_t calc_adjacent_blocks(gr_block_sptr block, 
gr_block_vector_t &blocks);
-    bool source_p(gr_block_sptr block);
-    gr_block_vector_t sort_sources_first(gr_block_vector_t &blocks);
-    void topological_dfs_visit(gr_block_sptr block, gr_block_vector_t &output);
+  void check_valid_port(gr_io_signature_sptr sig, int port);
+  void check_dst_not_used(const std::string &name, int port);
+  void check_type_match(gr_block_sptr src_block, int src_port,
+                       gr_block_sptr dst_block, int dst_port);
+  void validate();
+  gr_edge_vector_t calc_connections(const std::string &name, bool 
check_inputs); // false=use outputs
+  std::vector<int> calc_used_ports(const std::string &name, bool 
check_inputs); 
+  void check_contiguity(gr_block_sptr block, const std::vector<int> 
&used_ports, 
+                       bool check_inputs);
+  void setup_connections();
+  void merge_connections(gr_simple_flowgraph_sptr sfg);
+
+  gr_buffer_sptr allocate_buffer(const std::string &name, int port);
+  gr_block_vector_t calc_downstream_blocks(const std::string &name, int port);
+  gr_block_vector_t calc_downstream_blocks(const std::string &name);
+  gr_edge_vector_t calc_upstream_edges(const std::string &name);
+  gr_block_vector_t calc_used_blocks();
+  std::vector<gr_block_vector_t> partition();
+  gr_block_vector_t calc_reachable_blocks(gr_block_sptr block, 
gr_block_vector_t &blocks);
+  gr_block_vector_t topological_sort(gr_block_vector_t &blocks);
+  void reachable_dfs_visit(gr_block_sptr block, gr_block_vector_t &blocks);
+  gr_block_vector_t calc_adjacent_blocks(gr_block_sptr block, 
gr_block_vector_t &blocks);
+  bool source_p(gr_block_sptr block);
+  gr_block_vector_t sort_sources_first(gr_block_vector_t &blocks);
+  void topological_dfs_visit(gr_block_sptr block, gr_block_vector_t &output);
         
 public:
-    ~gr_simple_flowgraph_detail();
+  ~gr_simple_flowgraph_detail();
 };
 
 inline std::ostream&
 operator <<(std::ostream& os, const gr_block_sptr p)
 {
-    os << "<gr_block " << p->name() << " (" << p->unique_id() << ")>";
-    return os;
+  os << "<gr_block " << p->name() << " (" << p->unique_id() << ")>";
+  return os;
 }
 
 inline std::ostream&
 operator <<(std::ostream &os, const gr_endpoint endp)
 {
-    os << endp.name() << ":" << endp.port();
-    return os;
+  os << endp.name() << ":" << endp.port();
+  return os;
 }
 
 #endif /* INCLUDED_GR_SIMPLE_FLOWGRAPH_H */