Nested.cs

Go to the documentation of this file.

using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Runtime.Serialization;
 
using AnalyzeRe.Attributes;
using AnalyzeRe.Utilities;
 
namespace AnalyzeRe.Layers
{
    [APITypeAlias("NestedLayer")]
    public class Nested : Layer
    {
        #region Public Properties
        [DataMember(Order = 20)]
        [NotNull]
        public IReference<ILayerSource> sink { get; set; }
 
        [IgnoreDataMember]
        [NotNull]
        [NotEmpty]
        public Sources sources { get; set; }
 
        [DataMember(Order = 21, Name = "sources"), InternalMember]
        private List<IReference<ILayerSource>> SourcesAsReferenceList
        {
            get => sources?.References;
            set => sources = new Sources(value);
        }
        #endregion Public Properties
 
        public Nested()
        {
            sources = new Sources();
        }
 
        public sealed class Sources : APIType, IList<IReference<ILayerSource>>, IList
            , IReadOnlyList<IReference<ILayerSource>>
        {
            public List<IReference<ILayerSource>> References { get; set; }
 
            #region Constructors
            public Sources()
            {
                References = new List<IReference<ILayerSource>>();
            }
 
            public Sources(List<IReference<ILayerSource>> sources)
            {
                References = sources;
            }
 
            public Sources(IEnumerable<IReference<ILayerSource>> sources) :
                this(new List<IReference<ILayerSource>>(sources ??
                    Enumerable.Empty<IReference<ILayerSource>>())) { }
 
            public Sources(params IReference[] sources) : this(sources, true) { }
 
            public Sources(IEnumerable<IReference> sources, bool automaticTyping = true) :
                this(sources?.Select(r => ResolveReference(r, automaticTyping))) { }
 
            public static implicit operator Sources(List<IReference<ILayer>> layerSources) =>
                new Sources(layerSources);
 
            public static implicit operator Sources(List<IReference<ILayerSource>> sourceReferenceList) =>
                new Sources(sourceReferenceList);
 
            public static implicit operator List<IReference<ILayerSource>>(Sources sourcesInstance) =>
                sourcesInstance?.References;
            #endregion Constructors
 
            #region Public Methods
            public void Add(IReference reference, bool automaticTyping = true) =>
                References.Add(ResolveReference(reference, automaticTyping));
 
            public void Add(IReference<ILayerView> layerViewReference) => References.Add(layerViewReference);
 
            public void Add(IReference<ILayer> layerReference) => References.Add(layerReference);
 
            public void Add(ILayer layer) => References.Add(layer.ToReference());
            #endregion Public Methods
 
            #region Private Methods
            private static IReference<ILayerSource> ResolveReference(IReference weaklyTyped, bool automaticTyping)
            {
                if (weaklyTyped is IReference<ILayer> || weaklyTyped is IReference<ILayerView>)
                    return (IReference<ILayerSource>)weaklyTyped;
                if (automaticTyping && TryCreateLayerReference(weaklyTyped, out IReference<ILayer> converted))
                    return converted;
                return ThrowInvalidLossSourceException(weaklyTyped);
            }
 
            private static bool TryCreateLayerReference(IReference reference, out IReference<ILayer> result,
                bool suppress_throw = false)
            {
                result = null;
                IReference<IAPIResource> weaklyTyped = reference as IReference<IAPIResource>;
                // If this reference has a generic type argument,
                // ensure it does not resolve to some non-layer collection.
                if (weaklyTyped?.CollectionName != null &&
                    weaklyTyped.CollectionName != Layer.CLASS_COLLECTION_NAME)
                {
                    if (suppress_throw) return false;
                    // Special case: if the user added a loss set reference, raise a more meaningful
                    // error message to guide them in the correct direction.
                    string additionalMessage = null;
                    if (weaklyTyped.CollectionName == LossSet.CLASS_COLLECTION_NAME)
                        additionalMessage = "You can use LossSet references as loss sources by " +
                            "simply attaching them to the sink layer's list of loss_sets, or by " +
                            "wrapping them with a no-op layer and including that layer as a source.";
                    ThrowInvalidLossSourceException(reference, additionalMessage);
                }
 
                // If this reference contains a layer instance, create a strongly typed layer reference
                if ((weaklyTyped?.resolved ?? false) && weaklyTyped.GetValue() is ILayer layerValue)
                {
                    Type layerType = layerValue.GetType();
                    // Only bother creating a runtime type if it's more derived than what we're doing below.
                    if (layerType != typeof(ILayer))
                        result = (IReference<ILayer>)Activator.CreateInstance(
                            typeof(IReference<>).MakeGenericTypeFast(layerValue.GetType()), reference);
                }
 
                // Otherwise, create a weakly-typed layer reference instance 
                if (result == null)
                    result = new Reference<ILayer>(reference);
                return true;
            }
 
            private static IReference<ILayerSource> ThrowInvalidLossSourceException(
                IReference reference, string additionalMessage = null)
            {
                string message = $"Invalid reference type {reference.GetType().NiceTypeName()}" +
                    " encountered. All sources should either be Layer or LayerView references.";
                if (additionalMessage != null)
                    message += $" {additionalMessage}";
                throw new InvalidCastException(message);
            }
            #endregion Private Methods
 
            #region List<T> Delegated Implementation
            public IEnumerator<IReference<ILayerSource>> GetEnumerator() => References.GetEnumerator();
 
            void ICollection<IReference<ILayerSource>>.Add(IReference<ILayerSource> item) => References.Add(item);
 
            public void Clear() => References.Clear();
 
            public bool Contains(IReference<ILayerSource> item) => References.Contains(item);
 
            public void CopyTo(IReference<ILayerSource>[] array, int arrayIndex) => References.CopyTo(array, arrayIndex);
 
            public bool Remove(IReference<ILayerSource> item) => References.Remove(item);
 
            public int Count => References.Count;
 
            public bool IsReadOnly => false;
 
            public int IndexOf(IReference<ILayerSource> item) => References.IndexOf(item);
 
            public void Insert(int index, IReference<ILayerSource> item) => References.Insert(index, item);
 
            public void RemoveAt(int index) => References.RemoveAt(index);
            
            public IReference<ILayerSource> this[int index]
            {
                get => References[index];
                set => References[index] = value;
            }
 
            #region Explicit Implementations
            IEnumerator IEnumerable.GetEnumerator() => ((IEnumerable)References).GetEnumerator();
            int IList.Add(object value) => ((IList)References).Add(value);
            bool IList.Contains(object value) => ((IList)References).Contains(value);
            void ICollection.CopyTo(Array array, int index) => ((ICollection)References).CopyTo(array, index);
            object ICollection.SyncRoot => ((ICollection)References).SyncRoot;
            bool ICollection.IsSynchronized => ((ICollection)References).IsSynchronized;
            int IList.IndexOf(object value) => ((IList)References).IndexOf(value);
            void IList.Insert(int index, object value) => ((IList)References).Insert(index, value);
            void IList.Remove(object value) => ((IList)References).Remove(value);
            bool IList.IsFixedSize => ((IList)References).IsFixedSize;
            object IList.this[int index]
            {
                get => ((IList)References)[index];
                set => ((IList)References)[index] = value;
            }
            #endregion Explicit Implementations
            #endregion List<T> Delegated Implementation
        }
    }
}