C# List.LongestSet方法代码示例

        protected virtual void __eval_internal_recursive(FSharpList<FScheme.Value> args, Dictionary<PortData, FScheme.Value> outPuts, int level = 0)
        {
            var argSets = new List<FSharpList<FScheme.Value>>();

            //create a zip of the incoming args and the port data
            //to be used for type comparison
            var portComparison =
                args.Zip(InPortData, (first, second) => new Tuple<Type, Type>(first.GetType(), second.PortType))
                    .ToList();
            var listOfListComparison = args.Zip(InPortData,
                (first, second) => new Tuple<bool, Type>(Utils.IsListOfLists(first), second.PortType));

            //there are more than zero arguments
            //and there is either an argument which does not match its expections
            //OR an argument which requires a list and gets a list of lists
            //AND argument lacing is not disabled
            if (ArgumentLacing != LacingStrategy.Disabled && args.Any() &&
                (portComparison.Any(x => x.Item1 == typeof (Value.List) && x.Item2 != typeof (Value.List)) ||
                    listOfListComparison.Any(x => x.Item1 && x.Item2 == typeof (Value.List))))
            {
                //if the argument is of the expected type, then
                //leave it alone otherwise, wrap it in a list
                int j = 0;
                foreach (var arg in args)
                {
                    //incoming value is list and expecting single
                    if (portComparison.ElementAt(j).Item1 == typeof (Value.List) &&
                        portComparison.ElementAt(j).Item2 != typeof (Value.List))
                    {
                        //leave as list
                        argSets.Add(((Value.List) arg).Item);
                    }
                        //incoming value is list and expecting list
                    else
                    {
                        //check if we have a list of lists, if so, then don't wrap
                        argSets.Add(
                            Utils.IsListOfLists(arg) && !AcceptsListOfLists(arg)
                                ? ((Value.List) arg).Item
                                : Utils.MakeFSharpList(arg));
                    }
                    j++;
                }

                IEnumerable<IEnumerable<Value>> lacedArgs = null;
                switch (ArgumentLacing)
                {
                    case LacingStrategy.First:
                        lacedArgs = argSets.SingleSet();
                        break;
                    case LacingStrategy.Shortest:
                        lacedArgs = argSets.ShortestSet();
                        break;
                    case LacingStrategy.Longest:
                        lacedArgs = argSets.LongestSet();
                        break;
                    case LacingStrategy.CrossProduct:
                        lacedArgs = argSets.CartesianProduct();
                        break;
                }

                var evalResult = OutPortData.ToDictionary(
                    x => x,
                    _ => FSharpList<Value>.Empty);

                var evalDict = new Dictionary<PortData, Value>();

                //run the evaluate method for each set of
                //arguments in the lace result.
                foreach (var argList in lacedArgs)
                {
                    evalDict.Clear();

                    var thisArgsAsFSharpList = Utils.ToFSharpList(argList);

                    var portComparisonLaced =
                        thisArgsAsFSharpList.Zip(InPortData,
                            (first, second) => new Tuple<Type, Type>(first.GetType(), second.PortType)).ToList();

                    int jj = 0;
                    bool bHasListNotExpecting = false;
                    foreach (var argLaced in argList)
                    {
                        //incoming value is list and expecting single
                        if (ArgumentLacing != LacingStrategy.Disabled && thisArgsAsFSharpList.Any() &&
                            portComparisonLaced.ElementAt(jj).Item1 == typeof (Value.List) &&
                            portComparison.ElementAt(jj).Item2 != typeof (Value.List) &&
                            (!AcceptsListOfLists(argLaced) || !Utils.IsListOfLists(argLaced))
                            )
                        {
                            bHasListNotExpecting = true;
                            break;
                        }
                        jj++;
                    }
                    if (bHasListNotExpecting)
                    {
                        if (level > 20)
                            throw new Exception("Too deep recursive list containment by lists, only 21 are allowed");
                        Dictionary<PortData, FScheme.Value> outPutsLevelPlusOne =
//.........这里部分代码省略.........

        public override void Evaluate(FSharpList<Value> args, Dictionary<PortData, Value> outPuts)
        {
            //if this element maintains a collcection of references
            //then clear the collection
            if (this is IClearable)
                (this as IClearable).ClearReferences();

            List<FSharpList<Value>> argSets = new List<FSharpList<Value>>();

            //create a zip of the incoming args and the port data
            //to be used for type comparison
            var portComparison = args.Zip(InPortData, (first, second) => new Tuple<Type, Type>(first.GetType(), second.PortType));

            //if any value is a list whose expectation is a single
            //do an auto map
            //TODO: figure out a better way to do this than using a lot
            //of specific excludes
            if (args.Count() > 0 &&
                portComparison.Any(x => x.Item1 == typeof(Value.List) &&
                x.Item2 != typeof(Value.List)) &&
                !(this.ArgumentLacing == LacingStrategy.Disabled))
            {
                //if the argument is of the expected type, then
                //leave it alone otherwise, wrap it in a list
                int j = 0;
                foreach (var arg in args)
                {
                    //incoming value is list and expecting single
                    if (portComparison.ElementAt(j).Item1 == typeof(Value.List) &&
                        portComparison.ElementAt(j).Item2 != typeof(Value.List))
                    {
                        //leave as list
                        argSets.Add(((Value.List)arg).Item);
                    }
                    //incoming value is list and expecting list
                    else
                    {
                        //wrap in list
                        argSets.Add(Utils.MakeFSharpList(arg));
                    }
                    j++;
                }

                IEnumerable<IEnumerable<Value>> lacedArgs = null;
                switch (this.ArgumentLacing)
                {
                    case LacingStrategy.First:
                        lacedArgs = argSets.SingleSet();
                        break;
                    case LacingStrategy.Shortest:
                        lacedArgs = argSets.ShortestSet();
                        break;
                    case LacingStrategy.Longest:
                        lacedArgs = argSets.LongestSet();
                        break;
                    case LacingStrategy.CrossProduct:
                        lacedArgs = argSets.CartesianProduct();
                        break;
                }

                //setup a list to hold the results
                //each output will have its own results collection
                List<FSharpList<Value>> results = new List<FSharpList<FScheme.Value>>();
                for(int i=0; i<OutPortData.Count(); i++)
                {
                    results.Add(FSharpList<Value>.Empty);
                }
                //FSharpList<Value> result = FSharpList<Value>.Empty;

                //run the evaluate method for each set of
                //arguments in the la result. do these
                //in reverse order so our cons comes out the right
                //way around
                for (int i = lacedArgs.Count() - 1; i >= 0; i--)
                {
                    var evalResult = Evaluate(Utils.MakeFSharpList(lacedArgs.ElementAt(i).ToArray()));

                    //if the list does not have the same number of items
                    //as the number of output ports, then throw a wobbly
                    if (!evalResult.IsList)
                        throw new Exception("Output value of the node is not a list.");

                    for (int k = 0; k < OutPortData.Count(); k++)
                    {
                        FSharpList<Value> lst = ((Value.List)evalResult).Item;
                        results[k] = FSharpList<Value>.Cons(lst[k], results[k]);
                    }
                    runCount++;
                }

                //the result of evaluation will be a list. we split that result
                //and send the results to the outputs
                for (int i = 0; i < OutPortData.Count(); i++)
                {
                    outPuts[OutPortData[i]] = Value.NewList(results[i]);
                }

            }
            else
            {
//.........这里部分代码省略.........

        public override void Evaluate(FSharpList<Value> args, Dictionary<PortData, Value> outPuts)
        {
            //if this element maintains a collcection of references
            //then clear the collection
            if(this is IClearable)
                (this as IClearable).ClearReferences();

            List<FSharpList<Value>> argSets = new List<FSharpList<Value>>();

            //create a zip of the incoming args and the port data
            //to be used for type comparison
            var portComparison = args.Zip(InPortData,
                                          (first, second) => new Tuple<Type, Type>(first.GetType(), second.PortType));
            var listOfListComparison = args.Zip(InPortData, (first, second) => new Tuple<bool, Type>(Utils.IsListOfLists(first), second.PortType));

            //there are more than zero arguments
            //and there is either an argument which does not match its expections
            //OR an argument which requires a list and gets a list of lists
            //AND argument lacing is not disabled
            if (args.Count() > 0 &&
                (portComparison.Any(x => x.Item1 == typeof(Value.List) && x.Item2 != typeof(Value.List)) ||
                listOfListComparison.Any(x => x.Item1 == true && x.Item2 == typeof(Value.List))) &&
                this.ArgumentLacing != LacingStrategy.Disabled)
            {
                //if the argument is of the expected type, then
                //leave it alone otherwise, wrap it in a list
                int j = 0;
                foreach (var arg in args)
                {
                    //incoming value is list and expecting single
                    if (portComparison.ElementAt(j).Item1 == typeof (Value.List) &&
                        portComparison.ElementAt(j).Item2 != typeof (Value.List))
                    {
                        //leave as list
                        argSets.Add(((Value.List)arg).Item);
                    }
                    //incoming value is list and expecting list
                    else
                    {
                        //check if we have a list of lists, if so, then don't wrap
                        if (Utils.IsListOfLists(arg))
                            //leave as list
                            argSets.Add(((Value.List)arg).Item);
                        else
                            //wrap in list
                            argSets.Add(Utils.MakeFSharpList(arg));
                    }
                    j++;
                }

                IEnumerable<IEnumerable<Value>> lacedArgs = null;
                switch (this.ArgumentLacing)
                {
                    case LacingStrategy.First:
                        lacedArgs = argSets.SingleSet();
                        break;
                    case LacingStrategy.Shortest:
                        lacedArgs = argSets.ShortestSet();
                        break;
                    case LacingStrategy.Longest:
                        lacedArgs = argSets.LongestSet();
                        break;
                    case LacingStrategy.CrossProduct:
                        lacedArgs = argSets.CartesianProduct();
                        break;
                }

                //setup an empty list to hold results
                FSharpList<Value> result = FSharpList<Value>.Empty;

                //run the evaluate method for each set of
                //arguments in the cartesian result. do these
                //in reverse order so our cons comes out the right
                //way around
                for (int i = lacedArgs.Count() - 1; i >= 0; i--)
                {
                    var evalResult = Evaluate(Utils.MakeFSharpList(lacedArgs.ElementAt(i).ToArray()));
                    result = FSharpList<Value>.Cons(evalResult, result);
                }

                outPuts[OutPortData[0]] = Value.NewList(result);
            }
            else
            {
                outPuts[OutPortData[0]] = Evaluate(args);
            }

            ValidateConnections();

            if (dynSettings.Controller.UIDispatcher != null && this is IDrawable)
            {
                dynSettings.Controller.UIDispatcher.Invoke(new Action(() => (this as IDrawable).Draw()));
            }
        }