Merge branch 'merge_next' (which merges next)

This has been in the making far too long. We finally merge the next branch into master, in preparation of releasing GNU Radio 3.8. There will be breakage. There will be awesomeness. There will be progress in the greatest SDR framework to ever grace the surface of the earth. Hold tight for now.
author: Marcus Müller <marcus@hostalia.de> 2018-09-21 00:00:57 +0200
committer: Marcus Müller <marcus@hostalia.de> 2018-09-21 00:00:57 +0200
commit: 267d669eb21c514c18a6ee979f5cf247d251f1ad (patch)
tree: c6120f5993f82daf13894e8bf905c4169493152e /grc/core/Connection.py
parent: 896d1c9da31963ecf5b0d90942c2af51ca998a69 (diff)
parent: 7b20b28a9e5aa4e32ee37e89e7f80d74485344e8 (diff)
1 files changed, 60 insertions, 98 deletions
diff --git a/grc/core/Connection.py b/grc/core/Connection.py
index 49eae69c82..01baaaf8fc 100644
--- a/grc/core/Connection.py
+++ b/grc/core/Connection.py
@@ -17,131 +17,95 @@ along with this program; if not, write to the Free Software
 Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
 """
 
-from . import Constants
-from .Element import Element
-from .utils import odict
+from __future__ import absolute_import
+
+from .base import Element
+from .utils.descriptors import lazy_property
 
 
 class Connection(Element):
 
     is_connection = True
 
-    def __init__(self, flow_graph, porta, portb):
+    def __init__(self, parent, source, sink):
         """
         Make a new connection given the parent and 2 ports.
 
         Args:
             flow_graph: the parent of this element
-            porta: a port (any direction)
-            portb: a port (any direction)
+            source: a port (any direction)
+            sink: a port (any direction)
         @throws Error cannot make connection
 
         Returns:
             a new connection
         """
-        Element.__init__(self, flow_graph)
-        source = sink = None
-        # Separate the source and sink
-        for port in (porta, portb):
-            if port.is_source:
-                source = port
-            else:
-                sink = port
-        if not source:
+        Element.__init__(self, parent)
+
+        if not source.is_source:
+            source, sink = sink, source
+        if not source.is_source:
             raise ValueError('Connection could not isolate source')
-        if not sink:
+        if not sink.is_sink:
             raise ValueError('Connection could not isolate sink')
-        busses = len(filter(lambda a: a.get_type() == 'bus', [source, sink])) % 2
-        if not busses == 0:
-            raise ValueError('busses must get with busses')
-
-        if not len(source.get_associated_ports()) == len(sink.get_associated_ports()):
-            raise ValueError('port connections must have same cardinality')
-        # Ensure that this connection (source -> sink) is unique
-        for connection in flow_graph.connections:
-            if connection.get_source() is source and connection.get_sink() is sink:
-                raise LookupError('This connection between source and sink is not unique.')
-        self._source = source
-        self._sink = sink
-        if source.get_type() == 'bus':
-
-            sources = source.get_associated_ports()
-            sinks = sink.get_associated_ports()
-
-            for i in range(len(sources)):
-                try:
-                    flow_graph.connect(sources[i], sinks[i])
-                except:
-                    pass
+
+        self.source_port = source
+        self.sink_port = sink
 
     def __str__(self):
-        return 'Connection (\n\t{0}\n\t\t{1}\n\t{2}\n\t\t{3}\n)'.format(
-            self.get_source().get_parent(),
-            self.get_source(),
-            self.get_sink().get_parent(),
-            self.get_sink(),
+        return 'Connection (\n\t{}\n\t\t{}\n\t{}\n\t\t{}\n)'.format(
+            self.source_block, self.source_port, self.sink_block, self.sink_port,
         )
 
-    def is_msg(self):
-        return self.get_source().get_type() == self.get_sink().get_type() == 'msg'
+    def __eq__(self, other):
+        if not isinstance(other, self.__class__):
+            return NotImplemented
+        return self.source_port == other.source_port and self.sink_port == other.sink_port
 
-    def is_bus(self):
-        return self.get_source().get_type() == self.get_sink().get_type() == 'bus'
+    def __hash__(self):
+        return hash((self.source_port, self.sink_port))
 
-    def validate(self):
-        """
-        Validate the connections.
-        The ports must match in io size.
-        """
-        """
-        Validate the connections.
-        The ports must match in type.
-        """
-        Element.validate(self)
-        platform = self.get_parent().get_parent()
-        source_domain = self.get_source().get_domain()
-        sink_domain = self.get_sink().get_domain()
-        if (source_domain, sink_domain) not in platform.connection_templates:
-            self.add_error_message('No connection known for domains "{0}", "{1}"'.format(
-                    source_domain, sink_domain))
-        too_many_other_sinks = (
-            not platform.domains.get(source_domain, []).get('multiple_sinks', False) and
-            len(self.get_source().get_enabled_connections()) > 1
-        )
-        too_many_other_sources = (
-            not platform.domains.get(sink_domain, []).get('multiple_sources', False) and
-            len(self.get_sink().get_enabled_connections()) > 1
-        )
-        if too_many_other_sinks:
-            self.add_error_message(
-                'Domain "{0}" can have only one downstream block'.format(source_domain))
-        if too_many_other_sources:
-            self.add_error_message(
-                'Domain "{0}" can have only one upstream block'.format(sink_domain))
-
-        source_size = Constants.TYPE_TO_SIZEOF[self.get_source().get_type()] * self.get_source().get_vlen()
-        sink_size = Constants.TYPE_TO_SIZEOF[self.get_sink().get_type()] * self.get_sink().get_vlen()
-        if source_size != sink_size:
-            self.add_error_message('Source IO size "{0}" does not match sink IO size "{1}".'.format(source_size, sink_size))
+    def __iter__(self):
+        return iter((self.source_port, self.sink_port))
+
+    @lazy_property
+    def source_block(self):
+        return self.source_port.parent_block
+
+    @lazy_property
+    def sink_block(self):
+        return self.sink_port.parent_block
+
+    @lazy_property
+    def type(self):
+        return self.source_port.domain, self.sink_port.domain
 
-    def get_enabled(self):
+    @property
+    def enabled(self):
         """
         Get the enabled state of this connection.
 
         Returns:
             true if source and sink blocks are enabled
         """
-        return self.get_source().get_parent().get_enabled() and \
-            self.get_sink().get_parent().get_enabled()
+        return self.source_block.enabled and self.sink_block.enabled
 
-    #############################
-    # Access Ports
-    #############################
-    def get_sink(self):
-        return self._sink
+    def validate(self):
+        """
+        Validate the connections.
+        The ports must match in io size.
+        """
+        Element.validate(self)
+        platform = self.parent_platform
 
-    def get_source(self):
-        return self._source
+        if self.type not in platform.connection_templates:
+            self.add_error_message('No connection known between domains "{}" and "{}"'
+                                   ''.format(*self.type))
+
+        source_size = self.source_port.item_size
+        sink_size = self.sink_port.item_size
+        if source_size != sink_size:
+            self.add_error_message('Source IO size "{}" does not match sink IO size "{}".'.format(source_size, sink_size))
 
     ##############################################
     # Import/Export Methods
@@ -153,9 +117,7 @@ class Connection(Element):
         Returns:
             a nested data odict
         """
-        n = odict()
-        n['source_block_id'] = self.get_source().get_parent().get_id()
-        n['sink_block_id'] = self.get_sink().get_parent().get_id()
-        n['source_key'] = self.get_source().get_key()
-        n['sink_key'] = self.get_sink().get_key()
-        return n
+        return (
+            self.source_block.name, self.source_port.key,
+            self.sink_block.name, self.sink_port.key
+        )
author	Marcus Müller <marcus@hostalia.de>	2018-09-21 00:00:57 +0200
committer	Marcus Müller <marcus@hostalia.de>	2018-09-21 00:00:57 +0200
commit	267d669eb21c514c18a6ee979f5cf247d251f1ad (patch)
tree	c6120f5993f82daf13894e8bf905c4169493152e /grc/core/Connection.py
parent	896d1c9da31963ecf5b0d90942c2af51ca998a69 (diff)
parent	7b20b28a9e5aa4e32ee37e89e7f80d74485344e8 (diff)