コード例 #1
0
 public <T extends Object> XConnection createConnection(
     final T connectionObject,
     final ConnectionMapping<T> connectionMapping,
     final Procedure1<? super XConnection> initializer,
     final InterpreterContext context) {
   boolean _isApplicable = connectionMapping.isApplicable(connectionObject);
   if (_isApplicable) {
     final ConnectionMapping<T> connectionMappingCasted =
         ((ConnectionMapping<T>) connectionMapping);
     final IMappedElementDescriptor<T> descriptor =
         this.<T>getDescriptor(connectionObject, connectionMappingCasted);
     boolean _equals = Objects.equal(descriptor, null);
     if (_equals) {
       return null;
     }
     final XConnection existingConnection = context.getConnection(descriptor);
     boolean _or = false;
     boolean _notEquals = (!Objects.equal(existingConnection, null));
     if (_notEquals) {
       _or = true;
     } else {
       boolean _isCreateConnections = context.isCreateConnections();
       boolean _not = (!_isCreateConnections);
       _or = _not;
     }
     if (_or) {
       return existingConnection;
     }
     final XConnection connection = connectionMappingCasted.createConnection(descriptor);
     XDiagramConfig _config = connectionMappingCasted.getConfig();
     _config.initialize(connection);
     List<AbstractLabelMappingCall<?, T>> _labels = connectionMapping.getLabels();
     final Consumer<AbstractLabelMappingCall<?, T>> _function =
         (AbstractLabelMappingCall<?, T> it) -> {
           ObservableList<XConnectionLabel> _labels_1 = connection.getLabels();
           Iterable<? extends XLabel> _execute = this.execute(it, connectionObject);
           Iterable<XConnectionLabel> _filter =
               Iterables.<XConnectionLabel>filter(_execute, XConnectionLabel.class);
           Iterables.<XConnectionLabel>addAll(_labels_1, _filter);
         };
     _labels.forEach(_function);
     initializer.apply(connection);
     this.<T>createEndpoints(connectionMapping, connectionObject, connection, context);
     boolean _and = false;
     XNode _source = connection.getSource();
     boolean _notEquals_1 = (!Objects.equal(_source, null));
     if (!_notEquals_1) {
       _and = false;
     } else {
       XNode _target = connection.getTarget();
       boolean _notEquals_2 = (!Objects.equal(_target, null));
       _and = _notEquals_2;
     }
     if (_and) {
       context.addConnection(connection);
       return connection;
     }
   }
   return null;
 }
コード例 #2
0
 protected <T extends Object> void createEndpoints(
     final ConnectionMapping<T> connectionMapping,
     final T connectionObject,
     final XConnection connection,
     final InterpreterContext context) {
   boolean _and = false;
   XNode _source = connection.getSource();
   boolean _equals = Objects.equal(_source, null);
   if (!_equals) {
     _and = false;
   } else {
     NodeMappingCall<?, T> _source_1 = connectionMapping.getSource();
     boolean _notEquals = (!Objects.equal(_source_1, null));
     _and = _notEquals;
   }
   if (_and) {
     NodeMappingCall<?, T> _source_2 = connectionMapping.getSource();
     Iterable<XNode> _execute = null;
     if (_source_2 != null) {
       _execute = this.execute(_source_2, connectionObject, context);
     }
     XNode _head = IterableExtensions.<XNode>head(_execute);
     connection.setSource(_head);
   }
   boolean _and_1 = false;
   XNode _target = connection.getTarget();
   boolean _equals_1 = Objects.equal(_target, null);
   if (!_equals_1) {
     _and_1 = false;
   } else {
     NodeMappingCall<?, T> _target_1 = connectionMapping.getTarget();
     boolean _notEquals_1 = (!Objects.equal(_target_1, null));
     _and_1 = _notEquals_1;
   }
   if (_and_1) {
     NodeMappingCall<?, T> _target_2 = connectionMapping.getTarget();
     Iterable<XNode> _execute_1 = null;
     if (_target_2 != null) {
       _execute_1 = this.execute(_target_2, connectionObject, context);
     }
     XNode _head_1 = IterableExtensions.<XNode>head(_execute_1);
     connection.setTarget(_head_1);
   }
 }