private void OnConfig(IDiffSpread <string> spread)
{
if (!SkippedFirst)
{
// usually just the Default of the pin, any saved data will come next
SkippedFirst = true;
return;
// default of the pin already mimmicks default Formular for this node
}
var formular = Formular;
formular.Require(RequireEnum.None);
if (FFormularSelection.IsAnyInvalid())
{
formular.Name = MessageFormular.DYNAMIC;
}
else
{
formular.Name = FFormularSelection[0].Name;
}
// overwrite fiels that occur in FConfig
var config = new MessageFormular(MessageFormular.DYNAMIC, FConfig[0]);
foreach (var field in config.FieldDescriptors)
{
formular[field.Name] = field;
}
Formular = formular;
}
#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();
}
#pragma warning restore
public void Evaluate(int SpreadMax)
{
if ((!FInput.IsChanged && !FRemove.IsChanged))
{
return;
}
if ((FRemove.IsAnyInvalid() || FInput.IsAnyInvalid()))
{
if (FOutput.SliceCount > 0)
{
FOutput.FlushResult(FInput);
return;
}
else
{
return;
}
}
SpreadMax = FInput.SliceCount;
FOutput.SliceCount = SpreadMax;
for (int i = 0; i < SpreadMax; i++)
{
var remains = from msg in FInput[i]
where !FRemove.Contains(msg)
select msg;
FOutput[0].SliceCount = 0;
FOutput[0].AssignFrom(remains);
}
FOutput.Flush();
}
#pragma warning restore
public void Evaluate(int SpreadMax)
{
if (FInput.IsAnyInvalid())
{
SpreadMax = 0;
if (FOutput.SliceCount != 0)
{
FOutput.SliceCount = 0;
FOutput.Flush();
}
return;
}
else
{
SpreadMax = FInput.SliceCount;
}
if (!FInput.IsChanged && !FTopicAdd.IsChanged && !FContract.IsChanged)
{
return;
}
FOutput.SliceCount = 0;
for (int i = 0; i < SpreadMax; i++)
{
Message message = OSCExtensions.FromOSC(FInput[i], FExtendedMode[0], FTopicAdd[0], FContract[0]);
if (message != null)
{
FOutput.Add(message);
}
}
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 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);
}
//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);
}
//called when data for any output pin is requested
public void Evaluate(int SpreadMax)
{
if (FInput.IsAnyInvalid() || FIndex.IsAnyInvalid())
{
if (FOutput.SliceCount > 0)
{
FOutput.SliceCount = 0;
FOutput.Flush();
}
return;
}
if (!FInput.IsChanged && !FIndex.IsChanged)
{
return;
}
FOutput.SliceCount = 0;
var search = from message in FInput
let track = (message["TrackId"] as Bin <int>).First
where FIndex.Contains(track)
select message;
FOutput.AssignFrom(search);
FOutput.Flush();
}
#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.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)
{
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() || FExtendedMode.IsAnyInvalid())
{
SpreadMax = 0;
}
else
{
SpreadMax = FInput.SliceCount;
}
if (SpreadMax == 0)
{
if (FOutput.SliceCount != 0)
{
FOutput.SliceCount = 0;
FOutput.Flush();
}
return;
}
if (!FInput.IsChanged && !FExtendedMode.IsChanged)
{
return;
}
FOutput.SliceCount = SpreadMax;
for (int i = 0; i < SpreadMax; i++)
{
FOutput[i].SliceCount = 0;
MemoryStream ms = new MemoryComStream();
FInput[i].Position = 0;
FInput[i].CopyTo(ms);
byte[] bytes = ms.ToArray();
int start = 0;
OSCPacket packet = OSCPacket.Unpack(bytes, ref start, (int)FInput[i].Length, FExtendedMode[0]);
if (packet.IsBundle())
{
var packets = ((OSCBundle)packet).Values;
foreach (OSCPacket innerPacket in packets)
{
MemoryStream memoryStream = new MemoryStream(innerPacket.BinaryData);
FOutput[i].Add(memoryStream);
}
}
else
{
MemoryStream memoryStream = new MemoryStream(packet.BinaryData);
FOutput[i].Add(memoryStream);
}
}
FOutput.Flush();
}
protected virtual bool CheckReset()
{
var anyChange = CheckRemove();
if (!FReset.IsAnyInvalid() && FReset[0])
{
Keep.Clear();
anyChange = true;
}
return(anyChange);
}
public override void Evaluate(int SpreadMax)
{
if (FInput.IsAnyInvalid())
{
FOutput.FlushNil();
return;
}
bool doFlush = false;
// is any Update slice checked?
var anyUpdate = FUpdate.Any();
// Flush upstream changes through the plugin
if (FInput.IsChanged)
{
FOutput.SliceCount = 0;
FOutput.AssignFrom(FInput); // push change from upstream if valid
doFlush = true;
}
else if (!anyUpdate)
{
return; // if no update and no change, no need to flush!
}
bool newData = FPins.Any(pinName => pinName.Value.ToISpread().IsChanged); // changed pins
newData |= !FAutoSense[0]; // assume newData, if AutoSense is off.
if (anyUpdate && newData)
{
int messageIndex = 0;
foreach (var message in FInput)
{
if (FUpdate[messageIndex])
{
doFlush |= CopyFromPins(message, messageIndex, FAutoSense[0]);
}
messageIndex++;
}
}
if (doFlush)
{
FOutput.Flush();
}
if (RemovePinsFirst)
{
RetryConfig();
}
}
protected virtual bool CheckReset()
{
var anyChange = CheckRemove();
if (!FReset.IsAnyInvalid() && FReset[0])
{
Keep.Clear();
anyChange = true;
FCountOut.FlushItem <int>(Keep.Count);
}
return(anyChange);
}
protected virtual bool CheckRemove()
{
var anyChange = false;
if (!FRemove.IsAnyInvalid())
{
foreach (var message in FRemove)
{
anyChange |= Keep.Remove(message); // Remove will return false, if not in contained in Keep
}
}
return(anyChange);
}
private bool RemoveOldOrFlagged()
{
var validTime = Time.Time.CurrentTime() -
new TimeSpan(0, 0, 0, (int)Math.Floor(FTime[0]), (int)Math.Floor((FTime[0] * 1000) % 1000));
if (FTime[0] > 0)
{
DeadMessages = DeadMessages.Concat(
from message in Keep.ToList()
where message.TimeStamp < validTime
let removed = Keep.Remove(message)
select message
).ToList();
}
if (!FKillField.IsAnyInvalid() && FKillField[0].Trim() != "")
{
var killField = FKillField[0].Trim();
foreach (var message in Keep)
{
if (!message.Contains(killField))
{
continue;
}
var killFlag = message[killField].First as bool?;
if (killFlag != null && killFlag == true)
{
Keep.Remove(message);
DeadMessages.Add(message);
}
}
}
if (FRemovedMessages.SliceCount > 0 || DeadMessages.Count() > 0)
{
FRemovedMessages.SliceCount = 0;
FRemovedMessages.AssignFrom(DeadMessages);
FRemovedMessages.Flush();
DeadMessages.Clear();
return(true);
}
else
{
// output still empty, no need to flush
return(false);
}
}
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)
{
SpreadMax = FInput.IsAnyInvalid() ? 0 : FInput.SliceCount;
if (!FInput.IsChanged && !FExtendedMode.IsChanged)
{
return;
}
FOutput.SliceCount = SpreadMax;
for (int i = 0; i < SpreadMax; i++)
{
FOutput[i] = FInput[i].ToOSC(FExtendedMode[0]);
}
FOutput.Flush();
}
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);
}
}
protected void ConfigPin(IDiffSpread spread)
{
string typeAlias = "string";
if (!FAlias.IsAnyInvalid())
{
typeAlias = FAlias[0].Name;
}
var newConfig = typeAlias + " Value";
if (newConfig != FConfig[0])
{
FConfig[0] = newConfig; // first frame or user mistake will not reconfigure
}
}
#pragma warning restore
public void Evaluate(int SpreadMax)
{
var flow = FFlowControl[0];
FChange.SliceCount = 0;
switch (flow)
{
case FlowControlEnum.Block:
FChange.AssignFrom(Enumerable.Repeat(false, 1));
break;
case FlowControlEnum.Default:
if (FInput.IsChanged && !FInput.IsAnyInvalid())
{
FOutput.FlushResult(FInput);
FChange.AssignFrom(Enumerable.Repeat(true, 1));
}
else
{
FChange.AssignFrom(Enumerable.Repeat(false, 1));
}
break;
case FlowControlEnum.Inspect:
var change = FInput.Select(message => message.IsChanged);
if (FInput.IsChanged || change.Any())
{
FOutput.FlushResult(FInput);
FChange.AssignFrom(change);
}
else
{
FChange.AssignFrom(Enumerable.Repeat(false, 1));
}
break;
case FlowControlEnum.Force:
FOutput.FlushResult(FInput);
FChange.AssignFrom(Enumerable.Repeat(true, 1));
break;
default:
FChange.AssignFrom(Enumerable.Repeat(false, 1));
break;
}
}
#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);
}
public void Evaluate(int SpreadMax)
{
if (!FInput.IsChanged)
{
return;
}
SpreadMax = FInput.IsAnyInvalid() ? 0 : FInput.SliceCount;
FOutput.SliceCount = SpreadMax;
// FOutput.ResizeAndDispose(SpreadMax, () => new MemoryStream());
for (int i = 0; i < SpreadMax; i++)
{
FOutput[i] = new MemoryComStream(); // null exception. wrong usage of resiseAndDispose maybe?
serializer.Pack(FOutput[i], FInput[i]);
}
FOutput.Flush();
}
//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 override void Evaluate(int SpreadMax)
{
SpreadMax = FInput.IsAnyInvalid() ? 0 : FInput.SliceCount;
if (!FInput.IsChanged && !FExtendedMode.IsChanged)
{
return;
}
FOutput.SliceCount = SpreadMax;
for (int i = 0; i < SpreadMax; i++)
{
var fields = from fieldName in FUseFields[i]
select Formular[fieldName];
FOutput[i] = FInput[i].ToOSC(fields, FExtendedMode[0]);
}
FOutput.Flush();
}
//called when data for any output pin is requested
public void Evaluate(int SpreadMax)
{
if (FIndex.IsChanged)
{
Indices.Clear();
foreach (var id in FIndex)
{
int track = (int)id.x;
if (!Indices.ContainsKey(track))
{
Indices[track] = new HashSet <int>();
}
Indices[track].Add((int)id.y);
}
}
if (FInput.IsAnyInvalid() || FIndex.IsAnyInvalid())
{
if (FOutput.SliceCount > 0)
{
FOutput.SliceCount = 0;
FOutput.Flush();
}
return;
}
FOutput.SliceCount = 0;
var search = from message in FInput
let track = (message["TrackId"] as Bin <int>).First
where Indices.ContainsKey(track)
let clip = (message["ClipId"] as Bin <int>).First
where Indices[track].Contains(clip)
select message;
FOutput.AssignFrom(search);
FOutput.Flush();
}
public void Evaluate(int SpreadMax)
{
if (!FInput.IsChanged &&
!FTopic.IsChanged &&
!(FUpdate.IsChanged && FUpdate.Any())
)
{
return;
}
SpreadMax = FInput.IsAnyInvalid() ? 0 : FInput.SliceCount;
for (int i = 0; i < SpreadMax; i++)
{
// double check if topic change needs to occur, because setting it will mark the message as dirty
if (FUpdate[i] && !FInput[i].Topic.Equals(FTopic[i]))
{
FInput[i].Topic = FTopic[i];
}
}
FOutput.FlushResult(FInput);
}