AcRules.cs

Go to the documentation of this file.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
using System.Xml.Linq;

namespace AcUtils
{
    #region enums

    public enum RuleKind {
        unknown,
        clear,
        incl,
        incldo,
        excl
    };
    #endregion

    [Serializable]
    public sealed class AcRule : IFormattable, IEquatable<AcRule>, IComparable<AcRule>, IComparable
    {
        #region class variables
        private RuleKind _kind = RuleKind.unknown;
        private ElementType _type = ElementType.unknown;
        private string _location;
        private string _setInStream;
        private string _xlinkToStream;
        #endregion

        internal AcRule() { }

        #region Equality comparison

        public bool Equals(AcRule other)
        {
            if (ReferenceEquals(other, null)) return false;
            if (ReferenceEquals(this, other)) return true;
            var left = Tuple.Create(Kind, Location, SetInStream);
            var right = Tuple.Create(other.Kind, other.Location, other.SetInStream);
            return left.Equals(right);
        }

        public override bool Equals(object other)
        {
            if (ReferenceEquals(other, null)) return false;
            if (ReferenceEquals(this, other)) return true;
            if (GetType() != other.GetType()) return false;
            return this.Equals(other as AcRule);
        }

        public override int GetHashCode()
        {
            var hash = Tuple.Create(Kind, Location, SetInStream);
            return hash.GetHashCode();
        }
        #endregion

        #region Order comparison


        public int CompareTo(AcRule other)
        {
            int result;
            if (AcRule.ReferenceEquals(this, other))
                result = 0;
            else
            {
                result = String.Compare(SetInStream, other.SetInStream);
                if (result == 0)
                    result = String.Compare(Location, other.Location);
            }

            return result;
        }

        int IComparable.CompareTo(object other)
        {
            if (!(other is AcRule))
                throw new ArgumentException("Argument is not an AcRule", "other");
            AcRule o = (AcRule)other;
            return this.CompareTo(o);
        }
        #endregion

        public RuleKind Kind
        {
            get { return _kind; }
            internal set { _kind = value; }
        }

        public ElementType Type
        {
            get { return _type; }
            internal set { _type = value; }
        }

        public string Location
        {
            get { return _location ?? String.Empty; }
            internal set { _location = value; }
        }

        public string SetInStream
        {
            get { return _setInStream ?? String.Empty; }
            internal set { _setInStream = value; }
        }

        public string XlinkToStream
        {
            get { return _xlinkToStream ?? String.Empty; }
            internal set { _xlinkToStream = value; }
        }

        #region ToString
        public string ToString(string format, IFormatProvider provider)
        {
            if (provider != null)
            {
                ICustomFormatter fmt = provider.GetFormat(this.GetType()) as ICustomFormatter;
                if (fmt != null)
                    return fmt.Format(format, this, provider);
            }

            if (String.IsNullOrEmpty(format))
                format = "G";

            switch (format.ToUpperInvariant())
            {
                case "G":
                {
                    string text;
                    if (!String.IsNullOrEmpty(_xlinkToStream))
                        text = $"SetInStream: {SetInStream}{Environment.NewLine}" +
                                $"Cross-link (basis): {XlinkToStream}{Environment.NewLine}" +
                                $"Location: {Location}{Environment.NewLine}" +
                                $"Rule kind: {Kind}{Environment.NewLine}" +
                                $"Element type: {Type}{Environment.NewLine}";
                    else
                        text = $"SetInStream: {SetInStream}{Environment.NewLine}" +
                                $"Location: {Location}{Environment.NewLine}" +
                                $"Rule kind: {Kind}{Environment.NewLine}" +
                                $"Element type: {Type}{Environment.NewLine}";
                    return text;
                }
                case "K": // kind of rule in use
                    return Kind.ToString();
                case "T": // type of element the rule was placed on
                    return Type.ToString();
                case "L": // depot-relative path of the element the rule affects
                    return Location;
                case "S": // stream or workspace the rule is applied to
                    return SetInStream;
                case "X": // if cross-link the basis stream for the SetInStream
                    return XlinkToStream;
                default:
                    throw new FormatException($"The {format} format string is not supported.");
            }
        }

        // Calls ToString(string, IFormatProvider) version with a null IFormatProvider argument.
        public string ToString(string format)
        {
            return ToString(format, null);
        }

        // Calls ToString(string, IFormatProvider) version with the general format and a null IFormatProvider argument.
        public override string ToString()
        {
            return ToString("G", null);
        }
        #endregion ToString
    }


    [Serializable]
    public sealed class AcRules : List<AcRule>
    {
        private bool _explicitOnly;
        [NonSerialized] private readonly object _locker = new object(); // token for lock keyword scope
        [NonSerialized] private int _counter; // used to report initialization progress back to the caller

        #region object construction:


        public AcRules(bool explicitOnly = false)
        {
            _explicitOnly = explicitOnly;
        }


        public async Task<bool> initAsync(AcStream stream)
        {
            bool ret = false; // assume failure
            try
            {
                AcResult r = await AcCommand.runAsync($@"lsrules -s ""{stream}"" {(_explicitOnly ? "-d" : String.Empty)} -fx")
                    .ConfigureAwait(false);
                if (r != null && r.RetVal == 0)
                {
                    XElement xml = XElement.Parse(r.CmdResult);
                    foreach (XElement e in xml.Elements("element"))
                    {
                        AcRule rule = new AcRule();
                        string kind = (string)e.Attribute("kind");
                        rule.Kind = (RuleKind)Enum.Parse(typeof(RuleKind), kind);
                        string type = (string)e.Attribute("elemType");
                        rule.Type = (ElementType)Enum.Parse(typeof(ElementType), type);
                        rule.Location = (string)e.Attribute("location");
                        rule.SetInStream = (string)e.Attribute("setInStream");
                        rule.XlinkToStream = (string)e.Attribute("xlinkToStream") ?? String.Empty;
                        lock (_locker) { Add(rule); }
                    }

                    ret = true; // operation succeeded
                }
            }

            catch (AcUtilsException ecx)
            {
                AcDebug.Log($"AcUtilsException caught and logged in AcRules.initAsync(AcStream){Environment.NewLine}{ecx.Message}");
            }

            catch (Exception ecx)
            {
                AcDebug.Log($"Exception caught and logged in AcRules.initAsync(AcStream){Environment.NewLine}{ecx.Message}");
            }

            return ret;
        }

        public async Task<bool> initAsync(AcDepot depot, IProgress<int> progress = null)
        {
            bool ret = false; // assume failure
            try
            {
                int num = depot.Streams.Count();
                List<Task<bool>> tasks = new List<Task<bool>>(num);
                Func<Task<bool>, bool> cf = t =>
                {
                    bool res = t.Result;
                    if (res && progress != null) progress.Report(Interlocked.Increment(ref _counter));
                    return res;
                };

                foreach (AcStream stream in depot.Streams)
                {
                    Task<bool> t = initAsync(stream).ContinueWith(cf);
                    tasks.Add(t);
                }

                bool[] arr = await Task.WhenAll(tasks).ConfigureAwait(false);
                ret = (arr != null && arr.All(n => n == true)); // true if all succeeded
            }

            catch (Exception ecx)
            {
                AcDebug.Log($"Exception caught and logged in AcRules.initAsync(AcDepot){Environment.NewLine}{ecx.Message}");
            }

            return ret;
        }

        public async Task<bool> initAsync(StreamsCollection streamsCol, IProgress<int> progress = null)
        {
            bool ret = false; // assume failure
            try
            {
                AcDepots depots = new AcDepots();
                if (!(await depots.initAsync(null, progress).ConfigureAwait(false))) return false;
                int num = 0; // get number of streams for tasks list
                foreach (AcDepot depot in depots)
                {
                    IEnumerable<AcStream> filter = depot.Streams.Where(s =>
                        streamsCol.OfType<StreamElement>().Any(se => s.Name == se.Stream));
                    num += filter.Count();
                }

                List<Task<bool>> tasks = new List<Task<bool>>(num);
                Func<Task<bool>, bool> cf = t =>
                {
                    bool res = t.Result;
                    if (res && progress != null) progress.Report(Interlocked.Increment(ref _counter));
                    return res;
                };

                foreach (AcDepot depot in depots)
                {
                    IEnumerable<AcStream> filter = depot.Streams.Where(s =>
                        streamsCol.OfType<StreamElement>().Any(se => s.Name == se.Stream));
                    foreach (AcStream stream in filter)
                    {
                        Task<bool> t = initAsync(stream).ContinueWith(cf);
                        tasks.Add(t);
                    }
                }

                bool[] arr = await Task.WhenAll(tasks).ConfigureAwait(false);
                ret = (arr != null && arr.All(n => n == true)); // true if all succeeded
            }

            catch (Exception ecx)
            {
                AcDebug.Log($"Exception caught and logged in AcRules.initAsync(StreamsCollection){Environment.NewLine}{ecx.Message}");
            }

            return ret;
        }

        public async Task<bool> initAsync(DepotsCollection depotsCol, IProgress<int> progress = null)
        {
            bool ret = false; // assume failure
            try
            {
                AcDepots depots = new AcDepots();
                if (!(await depots.initAsync(depotsCol, progress).ConfigureAwait(false))) return false;
                int num = 0; // get number of streams for tasks list
                foreach (AcDepot depot in depots)
                    num += depot.Streams.Count();
                List<Task<bool>> tasks = new List<Task<bool>>(num);
                Func<Task<bool>, bool> cf = t =>
                {
                    bool res = t.Result;
                    if (res && progress != null) progress.Report(Interlocked.Increment(ref _counter));
                    return res;
                };

                foreach (AcStream stream in depots.SelectMany(d => d.Streams))
                {
                    Task<bool> t = initAsync(stream).ContinueWith(cf);
                    tasks.Add(t);
                }

                bool[] arr = await Task.WhenAll(tasks).ConfigureAwait(false);
                ret = (arr != null && arr.All(n => n == true));
            }

            catch (Exception ecx)
            {
                AcDebug.Log($"Exception caught and logged in AcRules.initAsync(DepotsCollection){Environment.NewLine}{ecx.Message}");
            }

            return ret;
        }
        #endregion
    }
}