public override void Evaluate(int SpreadMax)
{
// graceful fallback when being fed bad data
if (FNew.IsAnyInvalid() || FTopic.IsAnyInvalid() || FSpreadCount.IsAnyInvalid())
{
FOutput.FlushNil();
return;
}
if (!FNew.Any() && !ForceNewDefaults)
{
FOutput.FlushNil();
return;
}
SpreadMax = FFormularSelection.SliceCount; // numbers of supported Formulars
FOutput.SliceCount = SpreadMax;
var counter = 0;
for (int i = 0; i < SpreadMax; i++)
{
var formularName = FFormularSelection[i].Name;
MessageFormular formular;
try
{
formular = RetrieveRegisteredFormular(formularName);
} catch (RegistryException)
{
formular = null;
}
if (formular == null || formular.IsDynamic)
{
formular = new MessageFormular(formularName, ""); // empty fallback, in case not available or dynamic
}
FOutput[i].SliceCount = 0;
var count = FSpreadCount[i];
for (int j = 0; j < count; j++)
{
if (FNew[counter] || ForceNewDefaults)
{
Message message = new Message(formular);
message.Topic = FTopic[counter];
FOutput[i].Add(message);
}
counter++;
}
}
FOutput.Flush();
ForceNewDefaults = false;
}
//called when data for any output pin is requested
public void Evaluate(int SpreadMax)
{
// save some performance when no work necessary
if (FInput.IsAnyInvalid())
{
if (FOutput.SliceCount > 0)
{
FOutput.FlushNil();
}
return;
}
if (!FInput.IsChanged && !FFilter.IsChanged)
{
return;
}
// start working it out
var result =
from message in FInput
let bin = message["MyField"] as Bin <string> // identify as string
where bin != null
where !bin.IsAnyInvalid() && !FFilter.IsAnyInvalid() // safe against nil
where FFilter.Contains(bin.First)
select message;
// publish data back to vvvv
FOutput.FlushResult(result);
}
#pragma warning restore
public void Evaluate(int SpreadMax)
{
SpreadMax = FInput.IsAnyInvalid() ? 0 : FInput.SliceCount;
if (SpreadMax <= 0)
{
FOutput.FlushNil();
return;
}
var keepOnly = new HashSet <string>(FFilter);
foreach (var message in FInput)
{
foreach (var fieldName in message.Fields.ToArray())
{
if (!keepOnly.Contains(fieldName))
{
message.Remove(fieldName);
}
}
}
if (FRemoveEmpty[0])
{
FOutput.FlushResult(FInput.Where(message => !message.IsEmpty));
}
else
{
FOutput.FlushResult(FInput);
}
}
#pragma warning restore
public void Evaluate(int SpreadMax)
{
if (FInput.IsAnyInvalid())
{
SpreadMax = 0;
}
else
{
SpreadMax = FInput.SliceCount;
}
if (SpreadMax == 0)
{
FOutput.FlushNil();
return;
}
if (!FInput.IsChanged)
{
return;
}
var result = FInput.OrderBy(message => message.TimeStamp.UniversalTime);
FOutput.FlushResult(result);
}
public void Evaluate(int SpreadMax)
{
if (!FInput.IsChanged && !FFilter.IsChanged)
{
return;
}
if (FInput.IsAnyInvalid())
{
if (FOutput.SliceCount > 0)
{
FOutput.FlushNil();
}
return;
}
foreach (var message in FInput)
{
foreach (var fieldName in message.Fields.ToArray())
{
if (FFilter.Contains(fieldName))
{
message.Remove(fieldName);
}
}
}
FOutput.FlushResult(FInput);
}
public void Evaluate(int SpreadMax)
{
if (FInput.IsAnyInvalid())
{
if (FOutput.SliceCount > 0)
{
FOutput.FlushNil();
return;
}
else
{
return;
}
}
if (FRemove.IsAnyInvalid())
{
FOutput.FlushResult(FInput);
return;
}
if ((!FInput.IsChanged && !FRemove.IsChanged))
{
return;
}
var remains = from msg in FInput
where !FRemove.Contains(msg)
select msg;
FOutput.FlushResult(remains);
}
#pragma warning restore
public void Evaluate(int SpreadMax)
{
if (FInput.IsAnyInvalid() || FFilter.IsAnyInvalid())
{
SpreadMax = 0;
}
else
{
SpreadMax = FInput.SliceCount;
}
if (SpreadMax == 0)
{
FOutput.FlushNil();
FNotFound.FlushNil();
return;
}
if (!FInput.IsChanged && !FFilter.IsChanged)
{
return;
}
FOutput.SliceCount = 0;
FNotFound.SliceCount = 0;
bool[] found = new bool[SpreadMax];
for (int i = 0; i < SpreadMax; i++)
{
found[i] = false;
}
for (int i = 0; i < FFilter.SliceCount; i++)
{
string[] filter = FFilter[i].Split('.');
var regex = FFilter[i].CreateWildCardRegex();
for (int j = 0; j < SpreadMax; j++)
{
if (!found[j])
{
found[j] = regex.IsMatch(FInput[j].Topic);
}
}
}
for (int i = 0; i < SpreadMax; i++)
{
if (found[i])
{
FOutput.Add(FInput[i]);
}
else
{
FNotFound.Add(FInput[i]);
}
}
FOutput.Flush();
FNotFound.Flush();
}
public void Evaluate(int SpreadMax)
{
SpreadMax = FInput.IsAnyInvalid() || FIndex.IsAnyInvalid()? 0 : FIndex.CombineWith(FIndex);
if (SpreadMax == 0)
{
FOutput.FlushNil();
return;
}
else
{
if (!FIndex.IsChanged && !FInput.IsChanged)
{
return;
}
}
FOutput.SliceCount = SpreadMax;
for (int i = 0; i < SpreadMax; i++)
{
FOutput[i].AssignFrom(FInput[FIndex[i]]);
}
FOutput.Flush();
}
#pragma warning restore
public void Evaluate(int SpreadMax)
{
SpreadMax = FInput.IsAnyInvalid() ? 0 : FInput.SliceCount;
if (SpreadMax <= 0)
{
FMatch.FlushNil();
FOutput.FlushNil();
return;
}
FMatch.SliceCount = FOutput.SliceCount = 0;
foreach (var message in FInput)
{
var match = new bool[FFilter.SliceCount];
for (int i = 0; i < FFilter.SliceCount; i++)
{
match[i] = message.Fields.Contains(FFilter[i]);
}
if (match.Any())
{
FOutput.Add(message);
FMatch.AddRange(match);
}
}
FOutput.Flush();
FMatch.Flush();
}
public override void Evaluate(int SpreadMax)
{
InitDX11Graph();
bool warnPinSafety = false;
if (RemovePinsFirst)
{
warnPinSafety = !RetryConfig();
}
if (!FNew.Any()) // if none true
{
FOutput.FlushNil();
return;
}
SpreadMax = FNew.CombineWith(FTopic);
foreach (string name in FPins.Keys)
{
var pin = FPins[name].ToISpread();
pin.Sync();
SpreadMax = Math.Max(pin.SliceCount, SpreadMax);
}
FOutput.SliceCount = 0;
for (int i = 0; i < SpreadMax; i++)
{
if (FNew[i])
{
var message = new Message();
message.Topic = FTopic[i];
foreach (string name in FPins.Keys)
{
var pin = FPins[name].ToISpread();
if (pin.SliceCount > 0)
{
message.AssignFrom(name, pin[i] as ISpread);
}
else
{
message[name] = BinFactory.New(Formular[name].Type); // will do empty spreads as well, but ignore faults
}
}
FOutput.Add(message);
}
}
FOutput.Flush();
if (warnPinSafety)
{
throw new PinConnectionException("Manually remove unneeded links first! [Create]. ID = [" + PluginHost.GetNodePath(false) + "]");
}
}
public override void Evaluate(int SpreadMax)
{
if (!FNew.Any()) // if none true
{
FOutput.FlushNil();
if (RemovePinsFirst)
{
RetryConfig();
}
return;
}
SpreadMax = FNew.CombineWith(FTopic);
foreach (string name in FPins.Keys)
{
var pin = FPins[name].ToISpread();
pin.Sync();
SpreadMax = Math.Max(pin.SliceCount, SpreadMax);
}
FOutput.SliceCount = 0;
for (int i = 0; i < SpreadMax; i++)
{
if (FNew[i])
{
var message = new Message();
message.Topic = FTopic[i];
foreach (string name in FPins.Keys)
{
var pin = FPins[name].ToISpread();
if (pin.SliceCount > 0)
{
message.AssignFrom(name, pin[i] as ISpread);
}
else
{
message[name] = BinFactory.New(Formular[name].Type); // will do empty spreads as well, but ignore faults
}
}
FOutput.Add(message);
}
}
FOutput.Flush();
if (RemovePinsFirst)
{
RetryConfig();
}
}
public void Evaluate(int SpreadMax)
{
if (FInput.IsAnyInvalid())
{
SpreadMax = 0;
}
else
{
SpreadMax = FInput.SliceCount;
}
if (SpreadMax == 0)
{
if (FOutput.SliceCount != 0)
{
FOutput.FlushNil();
FEditCount.FlushNil();
}
return;
}
if (!FInput.IsChanged && !FModifier.IsChanged)
{
return;
}
FEditCount.SliceCount = SpreadMax;
for (int i = 0; i < SpreadMax; i++)
{
FEditCount[i] = 0;
var message = FInput[i];
var targets =
from mod in FModifier
where mod != null
where mod.Topic == message.Topic
select mod;
foreach (var mod in targets)
{
message.InjectWith(mod, FDeepInspection[0]);
FEditCount[i]++;
}
}
FOutput.FlushResult(FInput);
FEditCount.Flush();
}
public void Evaluate(int SpreadMax)
{
var output = new List <Message>();
var data = (from pin in FInputs
select !pin.IOObject.IsAnyInvalid()
).Any(d => d);
if (!data)
{
FOutput.FlushNil();
return;
}
var changed = (
from pin in FInputs
let spread = pin.IOObject
where spread.IsChanged
where !(FPinEmpty[spread] && spread.IsAnyInvalid()) // if IS emtpy and WAS empty, don't bother
select true
).Any();
if (!changed)
{
return;
}
var doDistinct = FDistinct[0];
for (int i = 0; i < FInputCount[0]; i++)
{
var inputSpread = FInputs[i].IOObject;
FPinEmpty[inputSpread] = inputSpread.IsAnyInvalid();
if (!inputSpread.IsAnyInvalid())
{
var filtered = from m in inputSpread
where m != null
where !m.IsEmpty
where !doDistinct || !output.Contains(m)
select m;
output.AddRange(filtered);
}
}
FOutput.FlushResult(output);
}
public void Evaluate(int SpreadMax)
{
if (FInit[0])
{
FOutput.FlushNil();
return;
}
_lastFrame.Clear();
if (FInput.IsChanged && !FInput.IsAnyInvalid())
{
_lastFrame.AddRange(FInput);
FOutput.FlushResult(_lastFrame);
}
}
public void Evaluate(int SpreadMax)
{
if (FInput.IsChanged)
{
LastFrame.AssignFrom(FInput);
}
if (!FClear.IsAnyInvalid() && FClear[0])
{
FOutput.FlushNil();
}
else
{
FOutput.FlushResult(LastFrame);
}
}
#pragma warning restore
public void Evaluate(int SpreadMax)
{
SpreadMax = FInput.IsAnyInvalid() ? 0 : FInput.SliceCount;
if (SpreadMax <= 0)
{
FOutput.FlushNil();
return;
}
var translate = new Dictionary <string, string>();
var max = FNew.CombineWith(FOld);
for (int i = 0; i < max; i++)
{
var n = FNew[i].Trim();
var o = FOld[i].Trim();
if (string.IsNullOrWhiteSpace(n) || string.IsNullOrWhiteSpace(o) || !n.IsValidFieldName())
{
throw new ParseFormularException("\"" + n + "\" is not a valid name for a Message's field. Only use alphanumerics, dots, hyphens and underscores. ");
}
translate[o] = n;
}
foreach (var message in FInput)
{
foreach (var fieldName in message.Fields.ToArray())
{
if (translate.ContainsKey(fieldName))
{
var success = message.Rename(fieldName, translate[fieldName], FOverwrite[0]);
if (!success)
{
FLogger.Log(LogType.Error, "Cannot rename " + fieldName + " to " + translate[fieldName] + " because it already exists.");
}
}
}
}
FOutput.FlushResult(FInput);
}
//called when data for any output pin is requested
public override void Evaluate(int SpreadMax)
{
if (!FInput.IsChanged)
{
return;
}
if (FInput.IsAnyInvalid())
{
FUnknown.FlushNil();
FChanged.SliceCount = FKeep.SliceCount;
}
// inject all incoming messages and keep a list of all
var idFields = from fieldName in FUseAsID
select fieldName.Name;
var changed = (
from message in FInput
where message != null
select MatchOrInsert(message, idFields)
).Distinct().ToList();
SpreadMax = FKeep.SliceCount;
FChanged.SliceCount = FOutput.SliceCount = SpreadMax;
for (int i = 0; i < SpreadMax; i++)
{
var message = FKeep[i];
FOutput[i] = message;
FChanged[i] = changed.Contains(message);
}
if (changed.Any())
{
FOutput.Flush();
FChanged.Flush();
}
}
#pragma warning restore
public override void Evaluate(int SpreadMax)
{
if (FInput.IsAnyInvalid())
{
SpreadMax = 0;
}
else
{
SpreadMax = FInput.SliceCount;
}
if (SpreadMax == 0)
{
FOutput.FlushNil();
return;
}
if (!FInput.IsChanged && !FUseFields.IsChanged)
{
return;
}
FOutput.SliceCount = 0;
var fieldNames = FUseFields[0];
if (fieldNames.IsAnyInvalid())
{
FOutput.FlushResult(FInput);
}
else
{
var ordered = FInput.OrderBy(message => message[fieldNames[0].Name][0]);
for (int i = 1; i < fieldNames.SliceCount; i++)
{
ordered = ordered.ThenBy(message => message[fieldNames[i].Name][0]);
}
FOutput.FlushResult(ordered);
}
}
public void Evaluate(int SpreadMax)
{
if ((!FInput.IsChanged))
{
return;
}
if (FInput.IsAnyInvalid())
{
FOutput.FlushNil();
return;
}
var remains = from msg in FInput
where msg != null
where !msg.IsEmpty
select msg;
FOutput.FlushResult(remains);
}
#pragma warning restore
public void Evaluate(int SpreadMax)
{
SpreadMax = FInput.IsAnyInvalid() ? 0 : FInput.SliceCount;
if (SpreadMax <= 0)
{
FOutput.FlushNil();
return;
}
foreach (var message in FInput)
{
foreach (var fieldName in message.Fields.ToArray())
{
if (message[fieldName].Count <= 0)
{
message.Remove(fieldName);
}
}
}
FOutput.FlushResult(FInput);
}
public override void Evaluate(int SpreadMax)
{
if (FInput.IsAnyInvalid())
{
if (FOutput.SliceCount > 0)
{
FOutput.FlushNil();
}
return;
}
SpreadMax = FInput.SliceCount;
if (!FInput.IsChanged && !FUseFields.IsChanged && !FDescending.IsChanged)
{
return;
}
if (FUseFields.IsAnyInvalid())
{
FOutput.FlushResult(FInput);
return;
}
// flatten, to ignore binsize. optimize potential!
List <EnumEntry> fieldNames = new List <EnumEntry>();
foreach (var bin in FUseFields)
{
foreach (var entry in bin)
{
if (entry != null && !fieldNames.Contains(entry))
{
fieldNames.Add(entry);
}
}
}
IOrderedEnumerable <Message> ordered = FInput.OrderBy(message => 1); // noop sort to "cast" into interface
for (int i = 0; i < fieldNames.Count; i++)
{
var fieldName = fieldNames[i].Name;
Func <Message, object> deleg;
switch (fieldName)
{
case "Topic":
deleg = message => message.Topic;
break;
case "TimeStamp":
deleg = message => message.TimeStamp.UniversalTime;
break;
default:
// todo: retrieve a proper default for this typed field
object fallBack = 1; // noop, when not possible
deleg = message =>
message[fieldName].IsAnyInvalid() ? fallBack
: message[fieldName][0];
break;
}
if (FDescending[i])
{
ordered = ordered.ThenByDescending(deleg);
}
else
{
ordered = ordered.ThenBy(deleg);
}
}
FOutput.FlushResult(ordered);
}
public override void Evaluate(int SpreadMax)
{
// graceful fallback when being fed bad data
if (FNew.IsAnyInvalid() || FTopic.IsAnyInvalid() || FSpreadCount.IsAnyInvalid())
{
FOutput.FlushNil();
return;
}
if (!FNew.Any() && !ForceNewDefaults)
{
FOutput.FlushNil();
return;
}
SpreadMax = FFormularSelection.SliceCount; // numbers of supported Formulars
FOutput.SliceCount = SpreadMax;
var counter = 0;
for (int i = 0; i < SpreadMax; i++)
{
var formularName = FFormularSelection[i].Name;
var formular = MessageFormularRegistry.Context[formularName];
FOutput[i].SliceCount = 0;
if (formular == null)
{
continue;
}
var count = FSpreadCount[i];
for (int j = 0; j < count; j++)
{
if (FNew[counter] || ForceNewDefaults)
{
Message message = new Message();
message.Topic = FTopic[counter];
foreach (var field in formular.FieldNames)
{
int binsize = formular[field].DefaultSize;
binsize = binsize > 0 ? binsize : 1;
var type = formular[field].Type;
message[field] = BinFactory.New(type, binsize);
for (int slice = 0; slice < binsize; slice++)
{
message[field].Add(TypeIdentity.Instance.NewDefault(type));
}
}
FOutput[i].Add(message);
}
counter++;
}
}
FOutput.Flush();
ForceNewDefaults = false;
}
public override void Evaluate(int SpreadMax)
{
// quit early. this will keep the last valid output until situation is resolved
if (RemovePinsFirst)
{
if (!RetryConfig())
{
throw new PinConnectionException("Manually remove unneeded links first! [Split]. ID = [" + PluginHost.GetNodePath(false) + "]");
}
else
{
LayoutChanged = true;
}
}
if (!FInput.IsChanged && !LayoutChanged)
{
return;
}
SpreadMax = FInput.IsAnyInvalid() ? 0 : FInput.SliceCount;
if (SpreadMax <= 0)
{
foreach (string name in FPins.Keys)
{
FPins[name].ToISpread().FlushNil();
}
FTopic.FlushNil();
FTimeStamp.FlushNil();
return;
}
FTimeStamp.SliceCount = SpreadMax;
FTopic.SliceCount = SpreadMax;
foreach (string name in FPins.Keys)
{
FPins[name].ToISpread().SliceCount = SpreadMax;
}
for (int i = 0; i < SpreadMax; i++)
{
Message message = FInput[i];
FTopic[i] = message.Topic;
FTimeStamp[i] = message.TimeStamp;
foreach (string name in FPins.Keys)
{
var targetPin = FPins[name].ToISpread();
var targetBin = targetPin[i] as ISpread;
Bin sourceBin = message[name];
int count = 0;
if (sourceBin as object == null)
{
if (FVerbose[0])
{
FLogger.Log(LogType.Warning,
"\"" + Formular[name].Type + " " + name + "\" is not defined in Message [" + message.Topic + "], so skipped its bin at \"" + PluginHost.GetNodePath(false) + "\".");
}
}
else
{
count = sourceBin.Count;
}
targetBin.SliceCount = count;
for (int j = 0; j < count; j++)
{
targetBin[j] = sourceBin[j];
}
}
}
FTimeStamp.Flush();
FTopic.Flush();
foreach (string name in FPins.Keys)
{
FPins[name].ToISpread().Flush();
}
// no need to worry next frame. all's well, because node did not fail early
LayoutChanged = false;
}
public void Evaluate(int SpreadMax)
{
SpreadMax = FInput.IsAnyInvalid() ? 0 : FInput.SliceCount;
if (SpreadMax == 0)
{
if (FOutput.SliceCount != 0)
{
FOutput.FlushNil();
FTimeStamp.FlushNil();
FTopic.FlushNil();
FConfigOut.FlushNil();
}
return;
}
if (!FInput.IsChanged)
{
return;
}
FOutput.SliceCount =
FTopic.SliceCount =
FConfigOut.SliceCount = SpreadMax;
var timeConnected = FTimeStamp.IsConnected; // treat the time pin a little different, because it can be quite slow. time type is a struct that gets copied within the pin
FTimeStamp.SliceCount = timeConnected? SpreadMax : 0;
for (int i = 0; i < SpreadMax; i++)
{
Message m = FInput[i];
FOutput[i] = m.ToString();
FTopic[i] = m.Topic;
if (timeConnected)
{
FTimeStamp[i] = m.TimeStamp;
}
;
FConfigOut[i] = FInput[i].Formular.Configuration;
if (FPrint[i])
{
//StringBuilder sb = new StringBuilder();
//sb.AppendLine("\t === \t ["+i+"]\t ===");
//sb.AppendLine(FInput[i].ToString());
//sb.AppendLine();
//FLogger.Log(LogType.Message, sb.ToString());
FLogger.Log(LogType.Message, "\t === \t [" + i + "]\t ===");
FLogger.Log(LogType.Message, JsonConvert.SerializeObject(FInput[i], FJsonSettings));
}
}
if (timeConnected)
{
FTimeStamp.Flush();
}
FTopic.Flush();
FOutput.Flush();
FConfigOut.Flush();
}
#pragma warning restore
public override void Evaluate(int SpreadMax)
{
if (FInput.IsAnyInvalid())
{
SpreadMax = 0;
FOutput.FlushNil();
FSuccess.FlushBool(false);
FMatch.FlushNil();
return;
}
else
{
SpreadMax = FInput.SliceCount;
}
var update = false;
if (FTopic.IsChanged || FExtendedMode.IsChanged || FUseFields.IsChanged || Parser == null)
{
if (Parser == null)
{
Parser = new Dictionary <string, IEnumerable <FormularFieldDescriptor> >();
}
else
{
Parser.Clear();
}
for (int i = 0; i < FTopic.SliceCount; i++)
{
var fields = (
from f in FUseFields[i]
select Formular[f.Name]
).ToList();
Parser[FTopic[i]] = fields;
}
update = true;
}
if (!update && !FInput.IsChanged)
{
return;
}
FSuccess.SliceCount = SpreadMax;
FOutput.SliceCount = 0;
FMatch.SliceCount = 0;
for (int i = 0; i < SpreadMax; i++)
{
var stream = FInput[i];
stream.Position = 0;
var address = OSCExtensions.PeekAddress(stream);
stream.Position = 0;
var isMatch = (
from a in FTopic
where address == a
select true
).Any();
Message message = isMatch? OSCExtensions.FromOSC(stream, Parser, FExtendedMode[0]) : null;
if (message != null)
{
FOutput.Add(message);
FSuccess[i] = true;
FMatch.Add(FTopic.IndexOf(address));
}
else
{
FSuccess[i] = false;
}
}
FOutput.Flush();
FSuccess.Flush();
FMatch.Flush();
}
