public Stream ToOSC()
{
OSCBundle bundle = new OSCBundle(this.TimeStamp.ToFileTime());
foreach (string name in MessageData.Keys)
{
string oscAddress = "";
foreach (string part in Address.Split('.'))
{
if (part.Trim() != "")
{
oscAddress += "/" + part;
}
}
foreach (string part in name.Split('.'))
{
if (part.Trim() != "")
{
oscAddress += "/" + part;
}
}
OSCMessage m = new OSCMessage(oscAddress);
SpreadList bl = MessageData[name];
for (int i = 0; i < bl.Count; i++)
{
m.Append(bl[i]);
}
bundle.Append(m);
}
return(new MemoryStream(bundle.BinaryData)); // packs implicitly
}
public XElement ToXElement()
{
XElement xml = new XElement("Message");
xml.Add(new XAttribute("address", this.Address));
foreach (var key in MessageData.Keys)
{
SpreadList data = MessageData[key];
var spread = new XElement("Spread");
spread.Add(new XAttribute("name", key));
spread.Add(new XAttribute("type", TypeIdentity.Instance[data.SpreadType].ToString()));
for (int i = 0; i < MessageData[key].Count; i++)
{
spread.Add(new XElement(TypeIdentity.Instance[data.SpreadType].ToString(), MessageData[key][i].ToString()));
}
xml.Add(spread);
}
return(xml);
}
public object Clone()
{
Message m = new Message();
m.Address = Address;
m.TimeStamp = TimeStamp;
foreach (string name in MessageData.Keys)
{
SpreadList list = MessageData[name];
m.Add(name, list.Clone());
// really deep cloning
try {
for (int i = 0; i < list.Count; i++)
{
list[i] = ((ICloneable)list[i]).Clone();
}
} catch (Exception err) {
err.ToString(); // no warning
// not cloneble. so keep it
}
}
return(m);
}
#pragma warning restore
public void Evaluate(int SpreadMax)
{
SpreadMax = FInput.SliceCount;
if (FInput.SliceCount == 0 || FInput[0] == null)
{
FOutput.SliceCount = 0;
return;
}
FOutput.SliceCount = SpreadMax;
for (int i = 0; i < SpreadMax; i++)
{
Message message = FInput[i];
if (Update[i])
{
for (int keyCount = 0; keyCount < FKey.SliceCount; keyCount++)
{
SpreadList attr = message[FKey[keyCount]];
if (attr != null)
{
var typeOld = attr[0].GetType();
var typeNew = FValue[keyCount][0].GetType();
if (!(typeOld == typeNew))
{
attr.Clear();
for (int j = 0; j < FValue[i].SliceCount; j++)
{
attr.Add(Convert.ChangeType(FValue[keyCount][j], typeOld));
}
}
else
{
attr.Clear();
attr.AssignFrom(FValue[i]);
}
}
}
}
FOutput[i] = message;
}
FOutput.Flush();
}
public static Message FromOSC(Stream stream, string messagePrefix = "OSC", int contractAddress = 1)
{
MemoryStream ms = new MemoryStream();
stream.Position = 0;
stream.CopyTo(ms);
byte[] bytes = ms.ToArray();
int start = 0;
OSCBundle bundle = OSCBundle.Unpack(bytes, ref start, (int)stream.Length);
Message message = new Message();
// yet unsupported:
// Message.TimeStamp = DateTime.FromFileTime(bundle.getTimeStamp());
foreach (OSCMessage m in bundle.Values)
{
SpreadList sl = new SpreadList();
sl.AssignFrom(m.Values); // does not clone implicitly
string oldAddress = m.Address;
while (oldAddress.StartsWith("/"))
{
oldAddress = oldAddress.Substring(1);
}
while (oldAddress.EndsWith("/"))
{
oldAddress = oldAddress.Substring(0, oldAddress.Length - 1);
}
string[] address = oldAddress.Split('/');
contractAddress = address.Length > contractAddress ? contractAddress : address.Length - ((messagePrefix.Trim() == "")? 1 : 0);
string attribName = "";
for (int i = address.Length - contractAddress; i < address.Length; i++)
{
attribName += ".";
attribName += address[i];
address[i] = "";
}
attribName = attribName.Substring(1);
string messageAddress = "";
foreach (string part in address)
{
if (part.Trim() != "")
{
messageAddress += "." + part;
}
}
if (messagePrefix.Trim() == "")
{
message.Address = messageAddress.Substring(1);
}
else
{
message.Address = messagePrefix + messageAddress;
}
message[attribName] = sl;
}
return(message);
}
public override void Evaluate(int SpreadMax)
{
TypeUpdate();
SpreadMax = (FSelect[0] != SelectEnum.First) ? FInput.SliceCount : 1;
if (!FInput.IsChanged)
{
// FLogger.Log(LogType.Debug, "skip split");
return;
}
bool empty = (FInput.SliceCount == 0) || (FInput[0] == null);
if (empty && (FHold[0] == HoldEnum.Off))
{
foreach (string name in FPins.Keys)
{
var pin = ToISpread(FPins[name]);
pin.SliceCount = 0;
pin.Flush();
}
FAddress.SliceCount = 0;
FTimeStamp.SliceCount = 0;
FAddress.Flush();
FTimeStamp.Flush();
return;
}
if (!empty)
{
foreach (string pinName in FPins.Keys)
{
if (FSelect[0] == SelectEnum.All)
{
ToISpread(FPins[pinName]).SliceCount = SpreadMax;
FTimeStamp.SliceCount = SpreadMax;
FAddress.SliceCount = SpreadMax;
}
else
{
ToISpread(FPins[pinName]).SliceCount = 1;
FTimeStamp.SliceCount = 1;
FAddress.SliceCount = 1;
}
}
for (int i = (FSelect[0] == SelectEnum.Last) ? SpreadMax - 1 : 0; i < SpreadMax; i++)
{
Message message = FInput[i];
FAddress[i] = message.Address;
FTimeStamp[i] = message.TimeStamp.ToString();
FAddress.Flush();
FTimeStamp.Flush();
foreach (string name in FPins.Keys)
{
var bin = (VVVV.PluginInterfaces.V2.NonGeneric.ISpread)ToISpread(FPins[name])[i];
SpreadList attrib = message[name];
int count = 0;
if (attrib == null)
{
if (FVerbose[0])
{
FLogger.Log(LogType.Debug, "\"" + FTypes[name] + " " + name + "\" is not defined in Message.");
}
}
else
{
count = attrib.Count;
}
if ((count > 0) || (FHold[0] != HoldEnum.Pin))
{
bin.SliceCount = count;
for (int j = 0; j < count; j++)
{
bin[j] = attrib[j];
}
ToISpread(FPins[name]).Flush();
}
else
{
// keep old values in pin. do not flush
}
}
}
}
}
