MapSelection.cs

using OSGeo.MapGuide.MaestroAPI.Feature;
using OSGeo.MapGuide.MaestroAPI.Serialization;
using OSGeo.MapGuide.ObjectModels;
using OSGeo.MapGuide.ObjectModels.SelectionModel;
using System;
using System.Collections.Generic;
using System.Xml;

namespace OSGeo.MapGuide.MaestroAPI.Mapping
{
    /// <summary>
    /// Represents a map selection
    /// </summary>
    /// <example>
    /// This sample shows how to list selected features in ASP.net. The sample expects 3 parameters:
    /// <list type="number">
    ///     <item><description>The session ID (SESSION)</description></item>
    ///     <item><description>The runtime map name (MAPNAME)</description></item>
    ///     <item><description>The selection XML (SELECTION)</description></item>
    /// </list>
    /// <code>
    /// <![CDATA[
    /// string agent = "http://localhost/mapguide/mapagent/mapagent.fcgi";
    /// IServerConnection conn = ConnectionProviderRegistry.CreateConnection(
    ///            "Maestro.Http",
    ///            "Url", agent,
    ///            "SessionId", Request.Params["SESSION"]);
    ///
    /// IMappingService mpSvc = (IMappingService)conn.GetService((int)ServiceType.Mapping);
    /// string rtMapId = "Session:" + conn.SessionID + "//" + Request.Params["MAPNAME"] + ".Map";
    /// RuntimeMap rtMap = mpSvc.OpenMap(rtMapId);
    ///
    /// string xml = Request.Params["SELECTION"];
    /// //The map selection contains one or more layer selections
    /// //each containing a one or more sets of identity property values
    /// //(because a feature may have multiple identity properties)
    ///
    /// MapSelection selection = new MapSelection(rtMap, System.Web.HttpUtility.UrlDecode(xml));
    /// if (selection.Count > 0)
    /// {
    ///     StringBuilder sb = new StringBuilder();
    ///     for (int i = 0; i < selection.Count; i++)
    ///     {
    ///         MapSelection.LayerSelection layerSel = selection[i];
    ///         sb.Append("<p>Layer: " + layerSel.Layer.Name + " (" + layerSel.Count + " selected item)");
    ///         sb.Append("<table>");
    ///         for (int j = 0; j < layerSel.Count; j++)
    ///         {
    ///             sb.Append("<tr>");
    ///             object[] values = layerSel[j];
    ///             for (int k = 0; k < values.Length; k++)
    ///             {
    ///                 sb.Append("<td>");
    ///                 sb.Append(values[k].ToString());
    ///                 sb.Append("</td>");
    ///             }
    ///             sb.AppendFormat("<td><a href='FeatureInfo.aspx?MAPNAME={0}&SESSION={1}&LAYERID={2}&ID={3}'>More Info</a></td>",
    ///                 rtMap.Name,
    ///                 conn.SessionID,
    ///                 layerSel.Layer.ObjectId,
    ///                 System.Web.HttpUtility.UrlEncode(layerSel.EncodeIDString(values)));
    ///             sb.Append("</tr>");
    ///         }
    ///         sb.Append("</table>");
    ///         Response.WriteLine("<p>Showing IDs of selected features</p>");
    ///         Response.WriteLine(sb.ToString());
    ///     }
    /// }
    /// else
    /// {
    ///     Response.WriteLine("Nothing selected. Select some features first then run this sample again.");
    /// }
    /// ]]>
    /// </code>
    /// </example>
    public class MapSelection : IBinarySerializable, IList<MapSelection.LayerSelection>
    {
        private RuntimeMap _map;
        private readonly List<LayerSelection> _layers;

        /// <summary>
        /// Constructor
        /// </summary>
        /// <param name="map"></param>
        public MapSelection(RuntimeMap map)
        {
            _map = map;
            _layers = new List<LayerSelection>();
        }

        /// <summary>
        /// Constructor
        /// </summary>
        /// <param name="map"></param>
        /// <param name="xml"></param>
        public MapSelection(RuntimeMap map, string xml)
            : this(map)
        {
            LoadXml(xml);
        }

        /// <summary>
        /// Initialize this selection from the specified xml string
        /// </summary>
        /// <param name="xml"></param>
        public void LoadXml(string xml)
        {
            _layers.Clear();

            XmlDocument doc = new XmlDocument();
            if (!string.IsNullOrEmpty(xml))
                doc.LoadXml(xml);

            //There are two variations
            XmlNodeList lst = doc.SelectNodes("FeatureSet/Layer"); //NOXLATE
            if (lst.Count == 0)
                lst = doc.SelectNodes("FeatureInformation/FeatureSet/Layer"); //NOXLATE

            foreach (XmlNode n in lst)
            {
                if (n.Attributes["id"] != null) //NOXLATE
                {
                    string guid = n.Attributes["id"].Value; //NOXLATE
                    var l = _map.Layers.GetByObjectId(guid);
                    if (l != null)
                    {
                        foreach (XmlNode c in n.SelectNodes("Class")) //NOXLATE
                        {
                            if (c.Attributes["id"] != null) //NOXLATE
                                if (c.Attributes["id"].Value == l.QualifiedClassName) //NOXLATE
                                    _layers.Add(new LayerSelection(l, c.SelectNodes("ID"))); //NOXLATE
                        }
                    }
                }
            }
        }

        /// <summary>
        /// Updates this selection from the given input selection set payload
        /// </summary>
        /// <param name="featureSet"></param>
        public void UpdateFrom(FeatureSet featureSet)
        {
            _layers.Clear();

            if (featureSet != null)
            {
                foreach (var layer in featureSet.Layer)
                {
                    var l = _map.Layers.GetByObjectId(layer.Id);
                    if (l != null)
                    {
                        var lsel = new LayerSelection(l, layer);
                        _layers.Add(lsel);
                    }
                }
            }
        }

        /// <summary>
        /// Returns an xml document that represents the current map selection
        /// </summary>
        /// <returns>An xml document that represents the current map selection</returns>
        public string ToXml()
        {
            XmlDocument doc = new XmlDocument();
            XmlNode root = doc.AppendChild(doc.CreateElement("FeatureSet")); //NOXLATE

            foreach (LayerSelection layer in _layers)
            {
                XmlNode ln = root.AppendChild(doc.CreateElement("Layer")); //NOXLATE
                ln.Attributes.Append(doc.CreateAttribute("id")).Value = layer.Layer.ObjectId; //NOXLATE

                XmlNode cn = ln.AppendChild(doc.CreateElement("Class")); //NOXLATE
                cn.Attributes.Append(doc.CreateAttribute("id")).Value = layer.Layer.QualifiedClassName; //NOXLATE

                for (int i = 0; i < layer.Count; i++)
                    cn.AppendChild(doc.CreateElement("ID")).InnerText = layer.EncodeIDString(layer[i]); //NOXLATE
            }

            return doc.OuterXml;
        }

        /// <summary>
        /// Represents a layer selection
        /// </summary>
        public class LayerSelection : IList<object[]>
        {
            private RuntimeMapLayer m_layer;
            private readonly List<object[]> m_list = new List<object[]>();

            /// <summary>
            /// Gets the layer that contains the selected objects
            /// </summary>
            public RuntimeMapLayer Layer => m_layer;

            /// <summary>
            /// Internal helper to construct a LayerSelection
            /// </summary>
            /// <param name="layer">The layer that the selection belongs to</param>
            /// <param name="ids">A list of xml &lt;ID&gt; nodes</param>
            internal LayerSelection(RuntimeMapLayer layer, XmlNodeList ids)
                : this(layer)
            {
                foreach (XmlNode n in ids)
                    Add(ParseIDString(n.InnerXml));
            }

            internal LayerSelection(RuntimeMapLayer layer, Layer selLayer)
                : this(layer)
            {
                foreach (var id in selLayer.Class.ID)
                    Add(ParseIDString(id));
            }

            /// <summary>
            /// Adds records from the specified reader into this selection
            /// </summary>
            /// <param name="reader">The reader</param>
            /// <param name="limit">The maximum number of records to add. Specify -1 for all</param>
            /// <returns>Number of records added</returns>
            public int AddFeatures(IReader reader, int limit)
            {
                int added = 0;
                if (limit < 0)
                {
                    while (reader.ReadNext())
                    {
                        AddFeature(reader);
                        added++;
                    }
                }
                else
                {
                    while (reader.ReadNext() && added < limit)
                    {
                        AddFeature(reader);
                        added++;
                    }
                }
                reader.Close();
                return added;
            }

            /// <summary>
            /// Adds the specified record to the selection
            /// </summary>
            /// <param name="record"></param>
            public void AddFeature(IRecord record)
            {
                var idProps = m_layer.IdentityProperties;
                object[] values = new object[idProps.Length];
                for (int i = 0; i < idProps.Length; i++)
                {
                    var prop = idProps[i];
                    //Don't null check because identity property values cannot be null
                    values[i] = record[prop.Name];
                }
                Add(values);
            }

            /// <summary>
            /// Encodes the given combined keyset into an ID string for use in the Xml
            /// </summary>
            /// <param name="values">The combined key</param>
            /// <returns>A base64 encoded ID string</returns>
            public string EncodeIDString(object[] values)
            {
                object[] tmp = NormalizeAndValidate(values);

                using (var ms = MemoryStreamPool.GetStream())
                {
                    for (int i = 0; i < m_layer.IdentityProperties.Length; i++)
                    {
                        Type type = m_layer.IdentityProperties[i].Type;

                        if (type == typeof(short))
                        {
                            byte[] x = BitConverter.GetBytes((short)tmp[i]);
                            ms.Write(x, 0, x.Length);
                        }
                        else if (type == typeof(int))
                        {
                            byte[] x = BitConverter.GetBytes((int)tmp[i]);
                            ms.Write(x, 0, x.Length);
                        }
                        else if (type == typeof(long))
                        {
                            byte[] x = BitConverter.GetBytes((long)tmp[i]);
                            ms.Write(x, 0, x.Length);
                        }
                        else if (type == typeof(double))
                        {
                            byte[] x = BitConverter.GetBytes((double)tmp[i]);
                            ms.Write(x, 0, x.Length);
                        }
                        else if (type == typeof(string))
                        {
                            byte[] x = System.Text.Encoding.UTF8.GetBytes((string)tmp[i]);
                            ms.Write(x, 0, x.Length);
                            ms.WriteByte(0);
                        }
                        else
                            throw new Exception(string.Format(Strings.ErrorUnsupportedPkType, type.ToString()));
                    }

                    return Convert.ToBase64String(ms.ToArray());
                }
            }

            /// <summary>
            /// Parses a base64 encoded string with key values
            /// </summary>
            /// <param name="id">The base64 encoded ID string</param>
            /// <returns>The composite value key</returns>
            public object[] ParseIDString(string id) => m_layer.ParseSelectionValues(id);

            /// <summary>
            /// Constructs a new LayerSelection with a number of selected featured
            /// </summary>
            /// <param name="layer">The layer to represent</param>
            /// <param name="ids">The list of composite IDs that the layer supports</param>
            public LayerSelection(RuntimeMapLayer layer, IEnumerable<object[]> ids)
                : this(layer)
            {
                AddRange(ids);
            }

            /// <summary>
            /// Constructs a new LayerSelection with a number of selected featured
            /// </summary>
            /// <param name="layer">The layer to represent</param>
            public LayerSelection(RuntimeMapLayer layer)
            {
                if (layer == null)
                    throw new ArgumentNullException(nameof(layer)); //NOXLATE

                if (layer.IdentityProperties.Length == 0 && layer.Parent.StrictSelection)
                    throw new Exception(Strings.ErrorLayerHasNoPk);

                m_layer = layer;
            }

            /// <summary>
            /// Adds a composite key to the selection
            /// </summary>
            /// <param name="values">The composite key</param>
            public void Add(object[] values)
            {
                object[] tmp = NormalizeAndValidate(values);

                if (!this.Contains(tmp))
                    m_list.Add(tmp);
            }

            /// <summary>
            /// Ensures that the composite key types match the layers ID column types.
            /// The returned array is a copy of the one passed in
            /// </summary>
            /// <param name="values">The composite key</param>
            /// <returns>A copy of the composite key</returns>
            private object[] NormalizeAndValidate(object[] values)
            {
                if (values == null)
                    throw new ArgumentNullException(nameof(values)); //NOXLATE

                if (values.Length != m_layer.IdentityProperties.Length)
                    throw new Exception(string.Format(Strings.ErrorLayerKeyMismatch, m_layer.IdentityProperties.Length, values.Length));

                object[] tmp = new object[values.Length];

                for (int i = 0; i < values.Length; i++)
                {
                    if (values[i] == null)
                        throw new Exception(string.Format(Strings.ErrorNullKeyValue, m_layer.IdentityProperties[i].Name));
                    if (values[i].GetType() != m_layer.IdentityProperties[i].Type)
                        try { tmp[i] = Convert.ChangeType(values[i], m_layer.IdentityProperties[i].Type); }
                        catch (Exception ex) { throw new Exception(string.Format(Strings.ErrorFailedValueConversion, m_layer.IdentityProperties[i].Name, values[i].GetType(), m_layer.IdentityProperties[i].Type), ex); }
                    else
                        tmp[i] = values[i];
                }

                return tmp;
            }

            /// <summary>
            /// Adds a number of composite keys
            /// </summary>
            /// <param name="lst">A list of composite keys</param>
            public void AddRange(IEnumerable<object[]> lst)
            {
                foreach (object[] x in lst)
                    Add(x);
            }

            #region IList<object[]> Members

            /// <summary>
            /// Returns the index of the given composite key
            /// </summary>
            /// <param name="item">The composite key to look for</param>
            /// <returns>The index of the composite key or -1 if the key is not found</returns>
            public int IndexOf(object[] item)
            {
                object[] tmp = NormalizeAndValidate(item);

                for (int i = 0; i < m_list.Count; i++)
                {
                    object[] tmpx = m_list[i];

                    bool matches = true;
                    for (int j = 0; j < tmpx.Length; j++)
                        if (tmpx[j] != item[j])
                        {
                            matches = false;
                            break;
                        }

                    if (matches)
                        return i;
                }

                return -1;
            }

            /// <summary>
            /// Inserts a key at the specified location
            /// </summary>
            /// <param name="index">The index to insert the key at</param>
            /// <param name="item">The key to insert</param>
            public void Insert(int index, object[] item)
            {
                object[] tmp = NormalizeAndValidate(item);

                int ix = IndexOf(tmp);

                if (ix >= 0)
                    RemoveAt(ix);

                Insert(index, item);
            }

            /// <summary>
            /// Removes the element at the specified location
            /// </summary>
            /// <param name="index">The index of the item to remove</param>
            public void RemoveAt(int index) => m_list.RemoveAt(index);

            /// <summary>
            /// Gets or sets the composite key for the specified index
            /// </summary>
            /// <param name="index">The index for the composite key</param>
            /// <returns>The composite key</returns>
            public object[] this[int index]
            {
                get
                {
                    object[] tmp = new object[m_layer.IdentityProperties.Length];
                    Array.Copy(m_list[index], tmp, tmp.Length);
                    return tmp;
                }
                set
                {
                    m_list[index] = NormalizeAndValidate(value);
                }
            }

            #endregion IList<object[]> Members

            #region ICollection<object[]> Members

            /// <summary>
            /// Removes all composite keys from the collection
            /// </summary>
            public void Clear() => m_list.Clear();

            /// <summary>
            /// Returns a value indicating if the composite key is contained in the collection
            /// </summary>
            /// <param name="item">The composite key to look for</param>
            /// <returns>True if the collection contains the composite key, false otherwise</returns>
            public bool Contains(object[] item) => IndexOf(item) >= 0;

            /// <summary>
            /// Not implemented
            /// </summary>
            /// <param name="array"></param>
            /// <param name="arrayIndex"></param>
            public void CopyTo(object[][] array, int arrayIndex)
            {
                throw new NotImplementedException();
            }

            /// <summary>
            /// Returns the number of composite keys (and thus selected objects)
            /// </summary>
            public int Count => m_list.Count;

            /// <summary>
            /// Gets a value indicating if the collection is read-only
            /// </summary>
            public bool IsReadOnly => false;

            /// <summary>
            /// Removes the given composite key from the collection
            /// </summary>
            /// <param name="item">The composite key to remove</param>
            /// <returns>True if the composite key was found and removed, false otherwise</returns>
            public bool Remove(object[] item)
            {
                int ix = IndexOf(item);
                if (ix < 0)
                    return false;

                m_list.RemoveAt(ix);
                return true;
            }

            #endregion ICollection<object[]> Members

            #region IEnumerable<object[]> Members

            /// <summary>
            /// Returns an enumerator for the collection
            /// </summary>
            /// <returns>An enumerator for the collection</returns>
            public IEnumerator<object[]> GetEnumerator() => m_list.GetEnumerator();

            #endregion IEnumerable<object[]> Members

            #region IEnumerable Members

            /// <summary>
            /// Returns an enumerator for the collection
            /// </summary>
            /// <returns>An enumerator for the collection</returns>
            System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() => ((System.Collections.IEnumerable)m_list).GetEnumerator();

            #endregion IEnumerable Members
        }

        /// <summary>
        /// Serializes this instance using the specified serializer.
        /// </summary>
        /// <param name="s">The serializer.</param>
        public void Serialize(MgBinarySerializer s)
        {
            var m_selection = new XmlDocument();
            m_selection.LoadXml(ToXml());
            if (m_selection["FeatureSet"] == null) //NOXLATE
            {
                s.Write((int)0);
                return;
            }

            XmlNodeList lst = m_selection["FeatureSet"].SelectNodes("Layer"); //NOXLATE
            s.Write(lst.Count);
            foreach (XmlNode n in lst)
            {
                if (n.Attributes["id"] == null) //NOXLATE
                    throw new Exception(Strings.ErrorSelectedLayerHasNoId);
                s.Write(n.Attributes["id"].Value); //NOXLATE

                XmlNodeList cls = n.SelectNodes("Class"); //NOXLATE
                s.Write(cls.Count);

                foreach (XmlNode c in cls)
                {
                    s.Write(c.Attributes["id"].Value); //NOXLATE
                    XmlNodeList ids = c.SelectNodes("ID"); //NOXLATE
                    s.Write(ids.Count);

                    foreach (XmlNode id in ids)
                        s.Write(id.InnerText);
                }
            }
        }

        /// <summary>
        /// Deserializes this object using the specified deserializer.
        /// </summary>
        /// <param name="d">The deserializer.</param>
        public void Deserialize(MgBinaryDeserializer d)
        {
            XmlDocument doc = new XmlDocument();
            XmlNode root = doc.AppendChild(doc.CreateElement("FeatureSet")); //NOXLATE
            int layerCount = d.ReadInt32();
            for (int i = 0; i < layerCount; i++)
            {
                XmlNode layer = root.AppendChild(doc.CreateElement("Layer")); //NOXLATE
                layer.Attributes.Append(doc.CreateAttribute("id")).Value = d.ReadString(); //NOXLATE

                int classCount = d.ReadInt32();
                for (int j = 0; j < classCount; j++)
                {
                    XmlNode @class = layer.AppendChild(doc.CreateElement("Class")); //NOXLATE
                    @class.Attributes.Append(doc.CreateAttribute("id")).Value = d.ReadString(); //NOXLATE

                    int idCount = d.ReadInt32();
                    for (int k = 0; k < idCount; k++)
                        @class.AppendChild(doc.CreateElement("ID")).InnerText = d.ReadString(); //NOXLATE
                }
            }
            LoadXml(doc.OuterXml);
        }

        #region IList<MapSelection.LayerSelection> Members

        /// <summary>
        /// Returns the index of the given layer
        /// </summary>
        /// <param name="item">The layer to look for</param>
        /// <returns>The index of the layer, or -1 if the layer is not in the collection</returns>
        public int IndexOf(LayerSelection item) => IndexOf(item.Layer);

        /// <summary>
        /// Returns the index of the given layer
        /// </summary>
        /// <param name="layer">The layer.</param>
        /// <returns>
        /// The index of the layer, or -1 if the layer is not in the collection
        /// </returns>
        public int IndexOf(RuntimeMapLayer layer)
        {
            for (int i = 0; i < _layers.Count; i++)
                if (_layers[i].Layer.ObjectId == layer.ObjectId)
                    return i;

            return -1;
        }

        /// <summary>
        /// Inserts a selection layer into the collection
        /// </summary>
        /// <param name="index">The index to place the item at</param>
        /// <param name="item">The item to insert</param>
        public void Insert(int index, LayerSelection item) => _layers.Insert(index, item);

        /// <summary>
        /// Inserts a selection layer into the collection
        /// </summary>
        /// <param name="index">The index to place the item at</param>
        /// <param name="layer">The layer.</param>
        public void Insert(int index, RuntimeMapLayer layer) => _layers.Insert(index, new LayerSelection(layer));

        /// <summary>
        /// Removes the item at the given index
        /// </summary>
        /// <param name="index">The index to remove the item at</param>
        public void RemoveAt(int index) => _layers.RemoveAt(index);

        /// <summary>
        /// Gets or sets the selection layer at a given index
        /// </summary>
        /// <param name="index">The index to get or set the item for</param>
        /// <returns>The item at the given index</returns>
        public LayerSelection this[int index]
        {
            get
            {
                return _layers[index];
            }
            set
            {
                if (value == null)
                    throw new ArgumentNullException();
                _layers[index] = value;
            }
        }

        /// <summary>
        /// Gets the selection layer at a given index
        /// </summary>
        /// <param name="index">The index to get or set the item for</param>
        /// <returns>The item at the given index</returns>
        public LayerSelection this[RuntimeMapLayer index] => _layers[IndexOf(index)];

        #endregion IList<MapSelection.LayerSelection> Members

        #region ICollection<MapSelection.LayerSelection> Members

        /// <summary>
        /// Adds the specified layer selection
        /// </summary>
        /// <param name="item"></param>
        public void Add(MapSelection.LayerSelection item)
        {
            if (item == null)
                throw new ArgumentNullException();

            _layers.Add(item);
        }

        /// <summary>
        /// Adds the specified layer
        /// </summary>
        /// <param name="layer"></param>
        public void Add(RuntimeMapLayer layer)
        {
            if (!Contains(layer))
            {
                var sel = new LayerSelection(layer);
                Add(sel);
            }
        }

        /// <summary>
        /// Clears this selction
        /// </summary>
        public void Clear() => _layers.Clear();

        /// <summary>
        /// Gets whether this selection contains the specified layer
        /// </summary>
        /// <param name="item"></param>
        /// <returns></returns>
        public bool Contains(RuntimeMapLayer item) => IndexOf(item) >= 0;

        /// <summary>
        /// Gets whether this selection contains the specified layer selection
        /// </summary>
        /// <param name="item"></param>
        /// <returns></returns>
        public bool Contains(LayerSelection item) => IndexOf(item) >= 0;

        /// <summary>
        /// Copies the elements of the <see cref="T:System.Collections.Generic.ICollection`1"/> to an <see cref="T:System.Array"/>, starting at a particular <see cref="T:System.Array"/> index.
        /// </summary>
        /// <param name="array">The one-dimensional <see cref="T:System.Array"/> that is the destination of the elements copied from <see cref="T:System.Collections.Generic.ICollection`1"/>. The <see cref="T:System.Array"/> must have zero-based indexing.</param>
        /// <param name="arrayIndex">The zero-based index in <paramref name="array"/> at which copying begins.</param>
        /// <exception cref="T:System.ArgumentNullException">
        ///   <paramref name="array"/> is null.
        ///   </exception>
        ///
        /// <exception cref="T:System.ArgumentOutOfRangeException">
        ///   <paramref name="arrayIndex"/> is less than 0.
        ///   </exception>
        ///
        /// <exception cref="T:System.ArgumentException">
        ///   <paramref name="array"/> is multidimensional.
        /// -or-
        ///   <paramref name="arrayIndex"/> is equal to or greater than the length of <paramref name="array"/>.
        /// -or-
        /// The number of elements in the source <see cref="T:System.Collections.Generic.ICollection`1"/> is greater than the available space from <paramref name="arrayIndex"/> to the end of the destination <paramref name="array"/>.
        ///   </exception>
        public void CopyTo(LayerSelection[] array, int arrayIndex)
        {
            throw new NotImplementedException();
        }

        /// <summary>
        /// Gets the number of layers in this selection
        /// </summary>
        public int Count => _layers.Count;

        /// <summary>
        /// Gets whether this is read only
        /// </summary>
        public bool IsReadOnly => false;

        /// <summary>
        /// Removes the specified layer selection
        /// </summary>
        /// <param name="item"></param>
        /// <returns></returns>
        public bool Remove(LayerSelection item)
        {
            int ix = IndexOf(item);
            if (ix < 0)
                return false;

            _layers.RemoveAt(ix);
            return true;
        }

        #endregion ICollection<MapSelection.LayerSelection> Members

        #region IEnumerable<LayerSelection> Members

        /// <summary>
        /// Gets the layer selection enumerator
        /// </summary>
        /// <returns></returns>
        public IEnumerator<LayerSelection> GetEnumerator() => _layers.GetEnumerator();

        #endregion IEnumerable<LayerSelection> Members

        #region IEnumerable Members

        System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() => ((System.Collections.IEnumerable)_layers).GetEnumerator();

        #endregion IEnumerable Members
    }
}