AcStreams.cs

Go to the documentation of this file.

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

namespace AcUtils
{
    #region enums


    public enum StreamType {
        unknown,
        normal,
        dynamic,
        regular,
        workspace,
        snapshot,
        passthru,
        passthrough,
        gated,
        staging
    };
    #endregion

    [Serializable]
    [DebuggerDisplay("{Name} ({ID}) {Type}, basis: {BasisName} ({BasisID})")]
    public sealed class AcStream : IFormattable, IEquatable<AcStream>, IComparable<AcStream>, IComparable
    {
        #region class variables
        private string _name; // stream name
        private int _id; // stream ID number
        private string _basisName; // basis stream name
        private int _basisID; // basis stream ID number
        private AcDepot _depot; // depot where the stream resides
        private bool _isDynamic; // false in the case of workspace, snapshot and passthrough, true if normal
        private StreamType _type; // unknown, normal, dynamic, regular, workspace, snapshot, passthru, passthrough, gated, staging
        private DateTime? _time;  // basis time; XML attribute "time" only exists for snapshot streams (creation date) or when a dynamic stream has a time basis
        // note, the result of specifying 'As transaction #' in the GUI results in a time basis set on the stream
        private DateTime _startTime; // stream's creation time or last time its name, time basis or state (remove, reactivate, reparent) changed
        private bool _hidden; // hidden (removed) stream
        private bool _hasDefaultGroup; // true if the stream has a default group
        #endregion

        internal AcStream() { }

        #region Equality comparison

        public bool Equals(AcStream other)
        {
            if (ReferenceEquals(other, null)) return false;
            if (ReferenceEquals(this, other)) return true;
            var left = Tuple.Create(ID, Depot);
            var right = Tuple.Create(other.ID, other.Depot);
            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 AcStream);
        }

        public override int GetHashCode()
        {
            var hash = Tuple.Create(ID, Depot);
            return hash.GetHashCode();
        }
        #endregion

        #region Order comparison


        public int CompareTo(AcStream other)
        {
            int result;
            if (AcStream.ReferenceEquals(this, other))
                result = 0;
            else
                result = String.Compare(Name, other.Name);

            return result;
        }

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

        public string Name
        {
            get { return _name ?? String.Empty; }
            internal set { _name = value; }
        }

        public int ID
        {
            get { return _id; }
            internal set { _id = value; }
        }

        public string BasisName
        {
            get { return _basisName ?? String.Empty; }
            internal set { _basisName = value; }
        }

        public int BasisID
        {
            get { return _basisID; }
            internal set { _basisID = value; }
        }

        public AcDepot Depot
        {
            get { return _depot; }
            internal set { _depot = value; }
        }

        public bool IsDynamic
        {
            get { return _isDynamic; }
            internal set { _isDynamic = value; }
        }

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


        public DateTime? Time
        {
            get { return _time; }
            internal set { _time = value; }
        }

        public DateTime StartTime
        {
            get { return _startTime; }
            internal set { _startTime = value; }
        }

        public bool Hidden
        {
            get { return _hidden; }
            internal set { _hidden = value; }
        }

        public bool HasDefaultGroup
        {
            get { return _hasDefaultGroup; }
            internal set { _hasDefaultGroup = value; }
        }

        public AcStream getBasis()
        {
            AcStream basis = _depot.getBasis(_id);
            return basis;
        }

        #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": // stream name; default when not using a format specifier
                    return Name; // general format should be short since it can be called by anything
                case "LV": // long version (verbose)
                    return $"{Name} ({ID}) {{{Type}}} {Time}{Environment.NewLine}" +
                            $"Basis: {BasisName} ({BasisID}){Environment.NewLine}" +
                            $"Depot: {Depot}, Hidden: {Hidden}{(Hidden ? String.Empty : ", HasDefaultGroup: " + HasDefaultGroup)}";
                case "I": // stream's ID number
                    return ID.ToString();
                case "T": // type of stream: unknown, normal, dynamic, regular, workspace, snapshot, passthru, passthrough, gated, staging
                    return Type.ToString();
                case "BT": // stream's time basis
                    return Time.ToString();
                case "C": // stream's creation time or last time its name, time basis or state (remove, reactivate, reparent) changed
                    return StartTime.ToString();
                case "BN": // basis stream name
                    return BasisName;
                case "BI": // basis stream ID number
                    return BasisID.ToString();
                case "D": // depot name
                    return Depot.ToString();
                case "DY": // true if dynamic, false in the case of workspace, snapshot or passthrough
                    return IsDynamic.ToString();
                case "H": // True if stream is hidden, False otherwise
                    return Hidden.ToString();
                case "DG": // True if stream has a default group, False otherwise
                    return HasDefaultGroup.ToString();
                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 AcStreams : List<AcStream>
    {
        #region class variables
        private bool _dynamicOnly; // true if request is for dynamic streams only
        private bool _includeHidden; // true if removed streams should be included
        [NonSerialized] private readonly object _locker = new object();
        #endregion

        #region object construction:


        internal AcStreams(bool dynamicOnly, bool includeHidden)
        {
            _dynamicOnly = dynamicOnly;
            _includeHidden = includeHidden;
        }


        internal async Task<bool> initAsync(AcDepot depot, string listfile = null)
        {
            bool ret = false; // assume failure
            try
            {
                AcResult result = await AcCommand.runAsync($@"show {(_includeHidden ? "-fxig" : "-fxg")} -p ""{depot}""" +
                    $@"{((listfile == null) ? String.Empty : "-l " + "" + listfile + "")} streams")
                    .ConfigureAwait(false);
                if (result != null && result.RetVal == 0)
                {
                    XElement xml = XElement.Parse(result.CmdResult);
                    IEnumerable<XElement> filter = null;
                    if (_dynamicOnly)
                        filter = from s in xml.Elements("stream")
                                 where (bool)s.Attribute("isDynamic") == true select s;
                    else
                        filter = from s in xml.Elements("stream") select s;

                    foreach (XElement e in filter)
                    {
                        AcStream stream = new AcStream();
                        stream.Name = (string)e.Attribute("name");
                        stream.ID = (int)e.Attribute("streamNumber");
                        stream.BasisName = (string)e.Attribute("basis") ?? String.Empty;
                        stream.BasisID = (int?)e.Attribute("basisStreamNumber") ?? -1;
                        stream.Depot = depot;
                        stream.IsDynamic = (bool)e.Attribute("isDynamic");
                        string type = (string)e.Attribute("type");
                        stream.Type = (StreamType)Enum.Parse(typeof(StreamType), type);
                        // attribute "time" only exists for snapshot streams (creation date) or when a dynamic stream has a time basis
                        stream.Time = e.acxTime("time"); // time basis
                        stream.StartTime = (DateTime)e.acxTime("startTime");
                        // hidden attribute exists only if the stream is hidden
                        stream.Hidden = (e.Attribute("hidden") != null);
                        stream.HasDefaultGroup = (bool)e.Attribute("hasDefaultGroup");
                        lock (_locker) { Add(stream); }
                    }

                    ret = true; // operation succeeded
                }
            }

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

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

            return ret;
        }
        #endregion

        public AcStream getStream(string name)
        {
            return this.SingleOrDefault(n => n.Name == name);
        }
    }
}