private void AddWriters(Node node, NodeReader reader, BufferTree tree, QueueIndex queue)
{
if (node.Index.Count > 0)
{
FieldWriter writer = new FieldWriter(node)
{
BufferIndex = node.Index.ToArray(),
NamePart = this.GetNamePart(node, queue, tree),
Queue = queue,
};
reader.Writers.Add(writer);
tree.Fields.Add(writer);
if (queue != null && queue.Type == RelationQueueType.Cached)
{
CacheWriter cacheWriter = new CacheWriter(node)
{
BufferIndex = writer.BufferIndex.First(),
CacheIndex = queue.Cache.Count,
Queue = queue,
};
queue.Cache.Add(cacheWriter);
}
}
if (node.Item != null || node.Metadata.HasFlag(RelationMetadataFlags.List | RelationMetadataFlags.Recursive))
{
QueueIndex prevQueue = tree.Queues.LastOrDefault()?.Index;
QueueIndex nextQueue = this.CreateIndex(node, tree);
QueueWriter writer = new QueueWriter(node)
{
NamePart = this.GetNamePart(node.Item ?? node, queue, tree),
Queue = queue,
Next = nextQueue,
};
if ((node.Item ?? node).Metadata.HasFlag(RelationMetadataFlags.Recursive))
{
nextQueue.Type = RelationQueueType.Recursive;
}
else if (prevQueue != null && !prevQueue.List.Identity.Equals(nextQueue.List.Owner.Parent?.Identity))
{
nextQueue.Type = RelationQueueType.Cached;
}
else if (prevQueue != null && prevQueue.Type == RelationQueueType.Cached)
{
nextQueue.Type = RelationQueueType.Cached;
}
reader.Writers.Add(writer);
if (node.Item != null)
{
this.CreateQueue(node.Item, tree, nextQueue);
}
}
}
private Expression GetAssignNewQueueExpression(QueueIndex index, int metadataOffset)
{
Expression arrayIndex = Expression.ArrayAccess(Arguments.Queues, Expression.Constant(index.Buffer));
Expression newQueue = this.GetNewQueueExpression(index, metadataOffset);
return(Expression.Assign(arrayIndex, newQueue));
}
private PropertyReader CreateProperty(Node node, BufferTree tree, QueueIndex queue)
{
PropertyReader reader = new PropertyReader(node);
this.AddWritersAndProperties(node, reader, tree, queue);
return(reader);
}
private Expression GetNewQueueExpression(QueueIndex index, int metadataOffset)
{
Type type = this.GetQueueGenericType(index);
ConstructorInfo ctor = type.GetConstructors()[0];
Expression metadata = Expression.ArrayAccess(Arguments.Metadata, Expression.Constant(metadataOffset + index.Buffer));
Expression queueType = Expression.Constant(index.Type);
return(Expression.New(ctor, metadata, queueType));
}
private QueueReader CreateQueue(Node node, BufferTree tree, QueueIndex queue)
{
QueueReader reader = new QueueReader(node)
{
Index = queue,
};
tree.Queues.Add(reader);
this.AddWritersAndProperties(node, reader, tree, queue);
return(reader);
}
public async Task <bool> Play()
{
DACPRequest request = new DACPRequest("/ctrl-int/1/playqueue-edit");
request.QueryParameters["command"] = "playnow";
request.QueryParameters["index"] = QueueIndex.ToString();
try
{
await Server.SubmitRequestAsync(request).ConfigureAwait(false);
}
catch { return(false); }
return(true);
}
private string GetNamePart(Node node, QueueIndex queue, BufferTree tree)
{
if (node.Metadata.HasFlag(RelationMetadataFlags.Recursive | RelationMetadataFlags.List))
{
string itemName = tree.Notation.Combine(node.Metadata.Identity.Name, tree.Notation.Member(queue.Item.Identity.Name));
return(tree.Notation.Path(queue.Item.Identity.Name, itemName));
}
else if (queue != null)
{
return(tree.Notation.Path(queue.Item.Identity.Name, node.Metadata.Identity.Name));
}
else
{
return(tree.Notation.Path(tree.Source.Metadata.Identity.Name, node.Metadata.Identity.Name));
}
}
private Expression GetCacheExpression(QueueIndex queue, Expression nonCachedWrite)
{
Expression isCached = this.GetQueuePropertyExpression(queue, "IsCached");
List <Expression> writeBody = new List <Expression>()
{
nonCachedWrite
};
List <Expression> readBody = new List <Expression>();
foreach (CacheWriter writer in queue.Cache)
{
writeBody.Add(this.GetCacheWriteExpression(writer));
readBody.Add(this.GetCacheReadExpression(writer));
}
return(Expression.IfThenElse(isCached, this.GetBlockOrExpression(readBody), this.GetBlockOrExpression(writeBody)));
}
private Expression GetQueuePropertyExpression(QueueIndex queue, string propertyName) => Expression.Property(queue.Variable, propertyName);
private Expression GetQueueIndexExpression(QueueIndex index)
{
Expression arrayIndex = Expression.ArrayAccess(Arguments.Queues, Expression.Constant(index.Buffer));
return(Expression.Convert(arrayIndex, index.Variable.Type));
}
private Type GetQueueItemGenericType(QueueIndex queue) => typeof(RelationQueueItem <>).MakeGenericType(queue.List.Type);
private void AddProperties(Node node, NodeReader reader, BufferTree tree, QueueIndex queue)
{
reader.Properties = node.Properties.Select(n => this.CreateProperty(n, tree, queue)).ToList();
}
private void AddWritersAndProperties(Node node, NodeReader reader, BufferTree tree, QueueIndex queue)
{
this.AddWriters(node, reader, tree, queue);
this.AddProperties(node, reader, tree, queue);
}
