public FlowConnector[] GetConnectorsForLayer(FlowConnector connector, bool isInput)
{
if (isInput)
{
return(this.m_Control.Elements
.Where(v => v is AlgorithmFlowElement)
.Select(v => v as AlgorithmFlowElement)
.Where(v => this.m_Layer.Inputs == null ? false : this.m_Layer.Inputs.Contains(v.m_Layer))
.Where(v => this.ParentsIndexOf(v.m_Layer).Contains(this.m_InputConnectors.IndexOf(connector)))
.Select(v => v.m_OutputConnectors[0])
.ToArray());
}
else
{
IEnumerable <AlgorithmFlowElement> lfe = this.m_Control.Elements
.Where(v => v is AlgorithmFlowElement)
.Select(v => v as AlgorithmFlowElement)
.Where(v => v.m_Layer.Inputs == null ? false : v.m_Layer.Inputs.Contains(this.m_Layer));
// TODO: Probably can be moved into LINQ query above.
List <FlowConnector> fll = new List <FlowConnector>();
foreach (AlgorithmFlowElement el in lfe)
{
for (int i = 0; i < el.m_InputConnectors.Count; i++)
{
if ((el.m_InputConnectors[i] as AlgorithmFlowConnector).ConnectedTo.Contains(this.m_OutputConnectors[0]))
{
fll.Add(el.m_InputConnectors[i]);
}
}
}
return(fll.ToArray());
}
}
ConsoleColor HeatMapped(
this FlowConnector <int> input, IEnumerable <ConsoleColor> palette, int min = 0, int max = 100)
{
IEnumerable <ConsoleColor> _palette = palette as ConsoleColor[] ?? palette.ToArray( );
return(_palette.ElementAt(( int )input.Scale(min, max, 0, _palette.Count( ))));
}
Concated <object, string> Append <TValue, TNew>(this FlowConnector <TValue> input, TNew appende)
{
IEnumerable <object> _in;
if (input.Value is IEnumerable)
{
_in = (( IEnumerable )input.Value).Cast <object>( );
}
else
{
_in = new object[] { input.Value };
}
IEnumerable <object> _appende;
if (appende is IEnumerable)
{
_appende = (( IEnumerable )appende).Cast <object>( );
}
else
{
_appende = new object[] { appende };
}
return
(new Concated <object, string>(
new List <object>(_in.Concat(_appende)), string.Empty));
}
public static IFlowConnector <T> Connector <T>(this IFlowSource <T> source, T @default = default)
{
var connector = new FlowConnector <T>(@default);
connector.ConnectTo(source);
return(connector);
}
Colored <string> HeatColored(
this FlowConnector <int> input, IEnumerable <ConsoleColor> palette, int min = 0, int max = 100)
{
IEnumerable <ConsoleColor> _palette = palette as ConsoleColor[] ?? palette.ToArray( );
return(" ".Let( ).Colored(
ConsoleColor.Black,
_palette.ElementAt(( int )input.Scale(min, max, 0, _palette.Count( )))));
}
protected virtual bool TryUpdateConnector(IConnector connector, ConnectionType connectionType, out IConnector newConnector)
{
if (GetFlowFor(connectionType) && connector is not FlowConnector)
{
newConnector = new FlowConnector(ParentNode, connectionType);
return(true);
}
newConnector = default;
return(false);
}
string EightBased(this FlowConnector <int> input)
{
return(Convert.ToString(input.Value, 8));
}
Colored <TIn> Colored <TIn>(this FlowConnector <TIn> input, ConsoleColor textColor, ConsoleColor backgroundColor = ConsoleColor.Black)
{
return(new Colored <TIn>(input.Value, textColor, backgroundColor));
}
Placed <TValue> Placed <TValue>(this FlowConnector <TValue> input, int x, int y)
{
return(new Placed <TValue>(input.Value, x, y));
}
Tagged <string, TValue> TaggedAsQuestion <TValue>(this FlowConnector <TValue> input)
{
return(input.Value.Let( ).Tagged("?"));
}
Tagged <TTag, TValue> Tagged <TTag, TValue>(this FlowConnector <TValue> input, TTag tag)
{
return(new Tagged <TTag, TValue>(tag, input.Value));
}
Tagged <string, TValue> TaggedAsError <TValue>(this FlowConnector <TValue> input)
{
return(input.Value.Let( ).Tagged("!"));
}
Tagged <string, TValue> TaggedAsInformation <TValue>(this FlowConnector <TValue> input)
{
return(input.Value.Let( ).Tagged(":"));
}
Concated <TValue, TDelimiter> Concated <TValue, TDelimiter>(
this FlowConnector <IEnumerable <TValue> > input, TDelimiter delimiter)
{
return(new Concated <TValue, TDelimiter>(new List <TValue>(input.Value), delimiter));
}
string Format(this FlowConnector <string> input, params object[] parameters)
{
return(string.Format(input.Value, parameters));
}
string HexBased(this FlowConnector <int> input)
{
return(Convert.ToString(input.Value, 16));
}
Concated <TValue, string> Concated <TValue>(
this FlowConnector <TValue[]> input, string delimiter = "")
{
return(new Concated <TValue, string>(new List <TValue>(input.Value), delimiter));
}
double Scale(this FlowConnector <int> input, int min, int max, double lowerLimit, double upperLimit)
{
return((((upperLimit - lowerLimit) * (input.Value - min)) / (max - min)) + lowerLimit);
}
Tagged <Colored <string>, Colored <TValue> > TaggedAsColoredError <TValue>(this FlowConnector <TValue> input)
{
return(input.Value.Let( ).Colored(ConsoleColor.DarkRed)
.Let( ).Tagged("!".Let( ).Colored(ConsoleColor.Red)));
}
Tagged <Colored <string>, Colored <TValue> > TaggedAsColoredWarning <TValue>(this FlowConnector <TValue> input)
{
return(input.Value.Let( ).Colored(ConsoleColor.DarkYellow)
.Let( ).Tagged("*".Let( ).Colored(ConsoleColor.Yellow)));
}
Tagged <Colored <string>, Colored <TValue> > TaggedAsColoredInformation <TValue>(this FlowConnector <TValue> input)
{
return(input.Value.Let( ).Colored(ConsoleColor.DarkGray)
.Let( ).Tagged(":".Let( ).Colored(ConsoleColor.White)));
}
Tagged <Colored <string>, Colored <TValue> > TaggedAsColoredQuestion <TValue>(this FlowConnector <TValue> input)
{
return(input.Value.Let( ).Colored(ConsoleColor.DarkGreen)
.Let( ).Tagged("?".Let( ).Colored(ConsoleColor.Green)));
}
