public void Find(Action <OuterJoinNode <T1, T2> > callback)
        {
            if (_node == null)
            {
                OuterJoinNode <T1, T2> joinNode = _left.Successors
                                                  .OfType <OuterJoinNode <T1, T2> >()
                                                  .Where(node => _matchRight(node.RightActivation))
                                                  .FirstOrDefault();

                if (joinNode != null)
                {
                    _node = joinNode;
                }
                else
                {
                    RightActivation <T2> rightActivation = _rightActivation();
                    _node = _configurator.Outer <T1, T2>(rightActivation);
                    _left.AddActivation(_node);
                }
            }

            if (_node != null)
            {
                callback(_node);
            }
        }
        public void Find(Action <LeftJoinNode <T, TDiscard> > callback)
        {
            if (_node == null)
            {
                LeftJoinNode <T, TDiscard> joinNode = _left.Successors
                                                      .OfType <LeftJoinNode <T, TDiscard> >()
                                                      .Where(node => _matchRight(node.RightActivation))
                                                      .FirstOrDefault();

                if (joinNode != null)
                {
                    _node = joinNode;
                }
                else
                {
                    RightActivation <T> rightActivation = _rightActivation();
                    _node = _configurator.Left <T, TDiscard>(rightActivation);
                    _left.AddActivation(_node);
                }
            }

            if (_node != null)
            {
                callback(_node);
            }
        }
Exemple #3
0
        public bool Find()
        {
            if (_node != null)
            {
                return(true);
            }

            WidenTypeNode <TInput, TOutput> widenTypeNode = _input.Successors
                                                            .OfType <WidenTypeNode <TInput, TOutput> >()
                                                            .FirstOrDefault();

            if (widenTypeNode != null)
            {
                _node = widenTypeNode;
            }
            else
            {
                _node = new WidenTypeNode <TInput, TOutput>(_output);
                _input.AddActivation(_node);
            }

            return(_node != null);
        }