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(); }