[Commit-gnuradio] r3767 - gnuradio/branches/developers/jcorgan/cppwrap/gnuradio-examples/native

[jcorgan]

Author: jcorgan
Date: 2006-10-10 14:06:34 -0600 (Tue, 10 Oct 2006)
New Revision: 3767

Modified:
   
gnuradio/branches/developers/jcorgan/cppwrap/gnuradio-examples/native/gr_flow_graph.cc
   
gnuradio/branches/developers/jcorgan/cppwrap/gnuradio-examples/native/gr_flow_graph.h
Log:
Work in progress.

Code reorganization and consolidation.  In Python, loops over list
members are cheap and easy.  In C++, they aren't, so several individual
methods which do so are now consolidated into one processing loop.


Modified: 
gnuradio/branches/developers/jcorgan/cppwrap/gnuradio-examples/native/gr_flow_graph.cc
===================================================================
--- 
gnuradio/branches/developers/jcorgan/cppwrap/gnuradio-examples/native/gr_flow_graph.cc
      2006-10-10 19:35:52 UTC (rev 3766)
+++ 
gnuradio/branches/developers/jcorgan/cppwrap/gnuradio-examples/native/gr_flow_graph.cc
      2006-10-10 20:06:34 UTC (rev 3767)
@@ -74,13 +74,8 @@
 {
     gr_edge_vector_iterator_t edge_iter;
     for(edge_iter = d_edges.begin(); edge_iter != d_edges.end(); edge_iter++) {
-       // For readability
-       gr_block_sptr dst_block = dst.first;
-       gr_block_sptr edge_block = edge_iter->second.first;
-       int dst_port = dst.second;
-       int edge_port = edge_iter->second.second;
-       
-       if (dst_block == edge_block && dst_port == edge_port)
+       gr_endpoint_t endp = edge_iter->second;
+       if (endp == dst)
            throw std::invalid_argument("gr_flow_graph::check_dst_not_used");
     }
 }
@@ -121,15 +116,6 @@
     d_edges.clear();
 }
 
-void gr_flow_graph::setup_connections()
-{
-    create_block_list();
-    validate();
-    assign_details();
-    assign_buffers();
-    connect_inputs();
-}
-
 void gr_flow_graph::create_block_list()
 {
     gr_block_vector_iterator_t block_iter;
@@ -150,63 +136,68 @@
     }
 }
 
-void gr_flow_graph::validate()
+void gr_flow_graph::connect_blocks()
 {
     gr_block_vector_iterator_t block_iter;
     for(block_iter = d_blocks.begin(); block_iter != d_blocks.end(); 
block_iter++) {
-       std::vector<int> used_inputs = calc_used_inputs(*block_iter);
-       std::vector<int> used_outputs = calc_used_outputs(*block_iter);
+       std::vector<int> used_inputs = calc_used_ports(*block_iter, false);
+       std::vector<int> used_outputs = calc_used_ports(*block_iter, true);
 
-       int ninputs = check_contiguity(*block_iter, 
(*block_iter)->input_signature(), used_inputs);
-       int noutputs = check_contiguity(*block_iter, 
(*block_iter)->output_signature(), used_outputs);
+       check_contiguity(*block_iter, (*block_iter)->input_signature(), 
used_inputs);
+       check_contiguity(*block_iter, (*block_iter)->output_signature(), 
used_outputs);
        
+       int ninputs = used_inputs.size();
+       int noutputs = used_outputs.size();
+
        if (!(*block_iter)->check_topology(ninputs, noutputs))
            throw std::invalid_argument("gr_flow_graph::validate");
-    }
-}
 
-// TODO: consolidate this and the next into one method
-std::vector<int> gr_flow_graph::calc_used_inputs(gr_block_sptr block)
-{
-    gr_edge_vector_iterator_t edge_iter;
-    std::vector<int> result;
-    
-    for(edge_iter = d_edges.begin(); edge_iter != d_edges.end(); edge_iter++) {
-       gr_block_sptr dst_block = edge_iter->second.first;
-       if (dst_block == block)
-           result.push_back(edge_iter->second.second);
+       // Block is good, now do per block processing
+
+       // 'assign_details' functionality here
+       printf("Assigning detail with %i inputs and %i outputs\n", ninputs, 
noutputs);
+       (*block_iter)->set_detail(gr_make_block_detail(ninputs, noutputs));
+
+       // 'assign_buffers' functionality here
+       
+       // 'connect_inputs' functionality here
     }
-    
-    sort(result.begin(), result.end());
-    unique(result.begin(), result.end());
-    return result;
 }
 
-std::vector<int> gr_flow_graph::calc_used_outputs(gr_block_sptr block)
+std::vector<int> gr_flow_graph::calc_used_ports(gr_block_sptr block, bool 
direction)
 {
     gr_edge_vector_iterator_t edge_iter;
     std::vector<int> result;
-    
+    gr_block_sptr cmp_block;
+        
     for(edge_iter = d_edges.begin(); edge_iter != d_edges.end(); edge_iter++) {
-       gr_block_sptr src_block = edge_iter->first.first;
-       if (src_block == block)
-           result.push_back(edge_iter->first.second);
+       if (!direction) { // inputs
+           cmp_block = edge_iter->second.first;
+           if (cmp_block == block)
+               result.push_back(edge_iter->second.second);
+       }
+       else { // outputs
+           cmp_block = edge_iter->first.first;
+           if (cmp_block == block)
+               result.push_back(edge_iter->first.second);
+       }
     }
     
+    // Remove duplicates
     sort(result.begin(), result.end());
     unique(result.begin(), result.end());
     return result;
 }
 
-int gr_flow_graph::check_contiguity(gr_block_sptr block, gr_io_signature_sptr 
sig,
-                                   std::vector<int> used_ports)
+void gr_flow_graph::check_contiguity(gr_block_sptr block, gr_io_signature_sptr 
sig,
+                                    std::vector<int> &used_ports)
 {
     int min_s = sig->min_streams();
     int l = used_ports.size();
     
     if (l == 0) {
        if (min_s == 0)
-           return 0;
+           return;
        else
            throw std::invalid_argument("gr_flow_graph::check_contiguity");
     }
@@ -219,34 +210,13 @@
            if (used_ports[i] != i)
                throw std::invalid_argument("gr_flow_graph::check_contiguity");
     }
-
-    return l;
 }
 
-void gr_flow_graph::assign_details()
-{
-    gr_block_vector_iterator_t block_iter;
-    for(block_iter = d_blocks.begin(); block_iter != d_blocks.end(); 
block_iter++) {
-       int ninputs = calc_used_inputs(*block_iter).size();
-       int noutputs = calc_used_outputs(*block_iter).size();
-
-       printf("Assigning detail with %i inputs and %i outputs\n", ninputs, 
noutputs);
-       (*block_iter)->set_detail(gr_make_block_detail(ninputs, noutputs));
-    }
-}
-
-void gr_flow_graph::assign_buffers()
-{
-}
-
-void gr_flow_graph::connect_inputs()
-{
-}
-
 void gr_flow_graph::start()
 {
     // TODO: check if already started
-    setup_connections();
+    create_block_list();
+    connect_blocks();
     // TODO: instantiate scheduler and call it with block list
 
     printf("If this were a real program, something interesting would have just 
happened.\n");

Modified: 
gnuradio/branches/developers/jcorgan/cppwrap/gnuradio-examples/native/gr_flow_graph.h
===================================================================
--- 
gnuradio/branches/developers/jcorgan/cppwrap/gnuradio-examples/native/gr_flow_graph.h
       2006-10-10 19:35:52 UTC (rev 3766)
+++ 
gnuradio/branches/developers/jcorgan/cppwrap/gnuradio-examples/native/gr_flow_graph.h
       2006-10-10 20:06:34 UTC (rev 3767)
@@ -47,17 +47,12 @@
     void check_dst_not_used(gr_endpoint_t dst);
     void check_type_match(gr_endpoint_t src, gr_endpoint_t dst);
     void disconnect_prim(gr_endpoint_t src, gr_endpoint_t dst);
-    void setup_connections();
     void create_block_list();
-    void validate();
-    std::vector<int> calc_used_inputs(gr_block_sptr block);
-    std::vector<int> calc_used_outputs(gr_block_sptr block);
-    int check_contiguity(gr_block_sptr block, gr_io_signature_sptr sig,
-                        std::vector<int> used_ports);
-    void assign_details();
-    void assign_buffers();
-    void connect_inputs();
-        
+    void connect_blocks();
+    std::vector<int> calc_used_ports(gr_block_sptr block, bool direction);
+    void check_contiguity(gr_block_sptr block, gr_io_signature_sptr sig,
+                         std::vector<int> &used_ports);
+
     gr_edge_vector_t  d_edges;
     gr_block_vector_t d_blocks;