DragonECS/src/Utils/LayersMap.cs

using System;
using System.Collections;
using System.Collections.Generic;

namespace DCFApixels.DragonECS.Core
{
    using VertexID = DependencyGraphVertextID;
    public class LayersMap : IDependencyGraph<string>
    {
        #region IDependencyGraph
        VertexID IDependencyGraph<string>.AddVertex(string vertex, bool isLocked) { return _graph.AddVertex(vertex, isLocked); }
        bool IDependencyGraph<string>.ContainsVertex(string vertex) { return _graph.ContainsVertex(vertex); }
        VertexID IDependencyGraph<string>.GetVertexID(string vertex) { return _graph.GetVertexID(vertex); }
        string IDependencyGraph<string>.GetVertexFromID(VertexID vertexID) { return _graph.GetVertexFromID(vertexID); }
        bool IDependencyGraph<string>.RemoveVertex(string vertex) { return _graph.RemoveVertex(vertex); }
        void IDependencyGraph<string>.AddDependency(VertexID fromID, VertexID toID, bool moveToRight) { _graph.AddDependency(fromID, toID, moveToRight); }
        string[] IDependencyGraph<string>.Sort() { return _graph.Sort(); }
        #endregion

        private readonly IDependencyGraph<string> _graph;
        private readonly EcsPipeline.Builder _pipelineBuilder;
        //private readonly string _preBeginLayer;

        #region Properties
        public EcsPipeline.Builder Back
        {
            get { return _pipelineBuilder; }
        }
        public int Count
        {
            get { return _graph.Count; }
        }
        public ReadonlyDependenciesCollection<string> Dependencies
        {
            get { return _graph.Dependencies; }
        }
        #endregion

        #region Constructors
        public LayersMap(IDependencyGraph<string> graph, EcsPipeline.Builder pipelineBuilder)
        {
            _graph = graph;
            _pipelineBuilder = pipelineBuilder;
        }
        public LayersMap(IDependencyGraph<string> graph, EcsPipeline.Builder pipelineBuilder, string preBeginlayer, string beginlayer, string basicLayer, string endLayer, string postEndLayer)
        {
            _graph = graph;
            _pipelineBuilder = pipelineBuilder;

            graph.AddVertex(preBeginlayer, true);
            graph.AddVertex(beginlayer, true);
            graph.AddVertex(basicLayer, true);
            graph.AddVertex(endLayer, true);
            graph.AddVertex(postEndLayer, true);

            Move(preBeginlayer);
            //.Before(beginlayer);
            Move(beginlayer)
                //.Before(basicLayer)
                .After(preBeginlayer);
            Move(basicLayer)
                //.Before(endLayer)
                .After(beginlayer);
            Move(endLayer)
                //.Before(postEndLayer)
                .After(basicLayer);
            Move(postEndLayer)
                .After(endLayer);
        }
        #endregion

        #region Add
        public MoveHandler Add(string layer)
        {
            VertexID id = _graph.AddVertex(layer, false);
            return new MoveHandler(_graph, _pipelineBuilder, id);
        }
        public MoveHandler Add(params string[] layers)
        {
            return Add(layersRange: layers);
        }
        public MoveHandler Add(IEnumerable<string> layersRange)
        {
            foreach (var layer in layersRange)
            {
                Add(layer);
            }
            return new MoveHandler(_graph, _pipelineBuilder, layersRange);
        }
        #endregion

        #region Move
        public MoveHandler Move(string layer)
        {
            VertexID id = _graph.GetVertexID(layer);
            return new MoveHandler(_graph, _pipelineBuilder, id);
        }
        public MoveHandler Move(params string[] layers)
        {
            return new MoveHandler(_graph, _pipelineBuilder, layers);
        }
        public MoveHandler Move(IEnumerable<string> layersRange)
        {
            return new MoveHandler(_graph, _pipelineBuilder, layersRange);
        }
        #endregion

        #region MoveHandler
        public struct MoveHandler
        {
            private readonly IDependencyGraph<string> _graph;
            private readonly EcsPipeline.Builder _pipelineBuilder;
            private readonly VertexID _layerID;
            private readonly IEnumerable<string> _layersRange;

            #region Properties
            public EcsPipeline.Builder Back
            {
                get { return _pipelineBuilder; }
            }
            #endregion

            #region Constructors
            public MoveHandler(IDependencyGraph<string> graph, EcsPipeline.Builder pipelineBuilder, VertexID id)
            {
                _graph = graph;
                _pipelineBuilder = pipelineBuilder;
                _layerID = id;
                _layersRange = null;
            }
            public MoveHandler(IDependencyGraph<string> graph, EcsPipeline.Builder pipelineBuilder, IEnumerable<string> layersRange)
            {
                _graph = graph;
                _pipelineBuilder = pipelineBuilder;
                _layerID = VertexID.NULL;
                _layersRange = layersRange;
            }
            #endregion

            #region Before
            public MoveHandler Before(params string[] targets)
            {
                return Before(targetsRange: targets);
            }
            public MoveHandler Before(IEnumerable<string> targetsRange)
            {
                foreach (var target in targetsRange)
                {
                    Before(target);
                }
                return this;
            }
            public MoveHandler Before(string targetLayer)
            {
                if (_layerID != VertexID.NULL)
                {
                    _graph.AddDependency(_layerID, _graph.GetVertexID(targetLayer), true);
                }
                if (_layersRange != null)
                {
                    foreach (var layer in _layersRange)
                    {
                        _graph.AddDependency(_graph.GetVertexID(layer), _graph.GetVertexID(targetLayer), true);
                    }
                }
                return this;
            }
            #endregion

            #region After
            public MoveHandler After(params string[] targets)
            {
                return After(targetsRange: targets);
            }
            public MoveHandler After(IEnumerable<string> targetsRange)
            {
                foreach (var target in targetsRange)
                {
                    After(target);
                }
                return this;
            }
            public MoveHandler After(string targetLayer)
            {
                if (_layerID != VertexID.NULL)
                {
                    _graph.AddDependency(_graph.GetVertexID(targetLayer), _layerID, false);
                }
                if (_layersRange != null)
                {
                    foreach (var layer in _layersRange)
                    {
                        _graph.AddDependency(_graph.GetVertexID(targetLayer), _graph.GetVertexID(layer), false);
                    }
                }
                return this;
            }
            #endregion
        }
        #endregion

        #region MergeWith
        public void MergeWith(IDependencyGraph<string> other)
        {
            _graph.MergeWith(other);
        }
        //[Obsolete("Use MergeWith(LayersMap)")]
        public void MergeWith(IReadOnlyList<string> other)
        {
            var enumerator = other.GetEnumerator();
            string prev = null;
            //if (_preBeginLayer != null)
            //{
            //    while (enumerator.MoveNext())
            //    {
            //        var layer = enumerator.Current;
            //        if (layer == _preBeginLayer) { break; }
            //
            //        Add(layer);
            //        if (prev != null)
            //        {
            //            Move(prev).Before(layer);
            //        }
            //        prev = layer;
            //    }
            //}
            while (enumerator.MoveNext())
            {
                var layer = enumerator.Current;
                Add(layer);
                if (prev != null)
                {
                    Move(layer).After(prev);
                }
                prev = layer;
            }
        }
        #endregion;

        #region Other
        public bool Contains(string layer)
        {
            return _graph.ContainsVertex(layer);
        }
        public IEnumerator<string> GetEnumerator() { return _graph.GetEnumerator(); }
        IEnumerator IEnumerable.GetEnumerator() { return _graph.GetEnumerator(); }
        #endregion

        #region Build
        public string[] Build()
        {
            return _graph.Sort();
        }
        #endregion
    }
}