MeteringGroupReference.cs

using System.Collections.Generic;
using System.Threading.Tasks;
using Waher.Runtime.Collections;
using Waher.Runtime.Language;
using Waher.Things;
using Waher.Things.Attributes;
 
namespace Waher.Groups.Metering.NodeTypes
{
    public class MeteringGroupReference : GroupNode, IGroup
    {
        public MeteringGroupReference()
        {
        }
 
        [Header(8, "Group ID:", 10)]
        [Page(4, "Group", 0)]
        [ToolTip(9, "Group ID of the group being referenced.")]
        [Required]
        public string ReferenceNodeId { get; set; }
 
        public override Task<string> GetTypeNameAsync(Language Language)
        {
            return Language.GetStringAsync(typeof(MeteringGroupReference), 10, "Metering Group Reference");
        }
 
        public override Task<bool> AcceptsChildAsync(INode Child)
        {
            return Task.FromResult(false);
        }
 
        public override Task<bool> AcceptsParentAsync(INode Parent)
        {
            return Task.FromResult(Parent is MeteringGroup);
        }
 
        public async Task<T[]> FindNodes<T>()
            where T : INode
        {
            ChunkedList<T> Nodes = new ChunkedList<T>();
            await this.FindNodes(Nodes);
            return Nodes.ToArray();
        }
 
        public async Task FindNodes<T>(ChunkedList<T> Nodes)
            where T : INode
        {
            INode Node = await GroupSource.GetNode(this.ReferenceNodeId);
 
            if (Node is null)
            {
                await this.LogErrorAsync("InvalidReference", "Group not found.");
                return;
            }
 
            if (Node is T TypedNode)
                Nodes.Add(TypedNode);
 
            ChunkedList<INode> CheckChildren = new ChunkedList<INode>() { Node };
 
            while (CheckChildren.HasFirstItem)
            {
                Node = CheckChildren.RemoveFirst();
                IEnumerable<INode> Children = await Node.ChildNodes;
 
                if (!(Children is null))
                {
                    foreach (INode Child in Children)
                    {
                        if (Child is T TypedChild)
                            Nodes.Add(TypedChild);
                        else
                            CheckChildren.Add(Child);
                    }
                }
            }
        }
    }
}