Stat.cs

Go to the documentation of this file.

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.Linq;
using System.Xml.Linq;

namespace AcUtils
{

    public enum ElementType {
        unknown = 0,
        dir = 1,
        text = 2,
        binary = 3,
        ptext = 4,
        elink = 5,
        slink = 6,
        unsupported = 99
    };

    [Serializable]
    [DebuggerDisplay("{EID} {Location} {Status} {NamedVersion}")]
    public sealed class Element : IFormattable, IEquatable<Element>, IComparable<Element>, IComparable
    {
        #region class variables
        private string _location;
        private bool _folder;
        private bool _executable;
        private int _eid;
        private ElementType _elementType;
        private long? _size;
        private DateTime? _modTime;
        private string _hierType;
        private int _virStreamNumber;
        private int _virVersionNumber;
        private string _namedVersion; // named stream\version number format, e.g. MARS_STAGE\7 or MARS_STAGE_barnyrd\24
        private int _realStreamNumber;
        private int _realVersionNumber;
        private string _lapStream;
        // AccuRev tech support, overlapInWs "was put in place for a feature that was started 
        // and then shelved and may be removed in a future release. Currently it is always true."
        // private bool _overlapInWs;
        private string _timeBasedStream;
        private string _status;
        #endregion

        #region Equality comparison

        public bool Equals(Element other)
        {
            if (ReferenceEquals(other, null)) return false;
            if (ReferenceEquals(this, other)) return true;
            var left = Tuple.Create(EID, VirStreamNumber, VirVersionNumber, RealStreamNumber, RealVersionNumber, NamedVersion);
            var right = Tuple.Create(other.EID, other.VirStreamNumber, other.VirVersionNumber,
                other.RealStreamNumber, other.RealVersionNumber, other.NamedVersion);
            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 Equals(other as Element);
        }

        public override int GetHashCode()
        {
            var hash = Tuple.Create(EID, VirStreamNumber, VirVersionNumber, RealStreamNumber, RealVersionNumber, NamedVersion);
            return hash.GetHashCode();
        }
        #endregion

        #region Order comparison

        public int CompareTo(Element other)
        {
            int result;
            if (Element.ReferenceEquals(this, other))
                result = 0;
            else
                result = Location.CompareTo(other.Location);

            return result;
        }

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

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

        public bool Folder
        {
            get { return _folder; }
            internal set { _folder = value; }
        }


        public bool Executable
        {
            get { return _executable; }
            internal set { _executable = value; }
        }

        public int EID
        {
            get { return _eid; }
            internal set { _eid = value; }
        }

        public ElementType ElementType
        {
            get { return _elementType; }
            internal set { _elementType = value; }
        }


        public long? Size
        {
            get { return _size; }
            internal set { _size = value; }
        }

        public DateTime? ModTime
        {
            get { return _modTime; }
            internal set { _modTime = value; }
        }

        public string HierType
        {
            get { return _hierType ?? String.Empty; }
            internal set { _hierType = value; }
        }

        public int VirStreamNumber
        {
            get { return _virStreamNumber; }
            internal set { _virStreamNumber = value; }
        }

        public int VirVersionNumber
        {
            get { return _virVersionNumber; }
            internal set { _virVersionNumber = value; }
        }

        public string NamedVersion
        {
            get { return _namedVersion ?? String.Empty; }
            internal set { _namedVersion = value; }
        }

        public int RealStreamNumber
        {
            get { return _realStreamNumber; }
            internal set { _realStreamNumber = value; }
        }

        public int RealVersionNumber
        {
            get { return _realVersionNumber; }
            internal set { _realVersionNumber = value; }
        }


        public string LapStream
        {
            get { return _lapStream ?? String.Empty; }
            internal set { _lapStream = value; }
        }


        public string TimeBasedStream
        {
            get { return _timeBasedStream ?? String.Empty; }
            internal set { _timeBasedStream = value; }
        }

        public string Status
        {
            get { return _status ?? String.Empty; }
            internal set { _status = 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 "LV": // long version (verbose)
                {
                    if (_modTime != null)
                        return $"{Location}, {Status}{Environment.NewLine}" +
                                $"\tEID: {EID} {{{ElementType}}}, Size: {Size}, ModTime: {ModTime},{Environment.NewLine}" +
                                $"\t{NamedVersion}, Virtual: {VirStreamNumber}\\{VirVersionNumber}, Real: {RealStreamNumber}\\{RealVersionNumber}";
                    else
                        return $"{Location}, {Status}{Environment.NewLine}" +
                                $"\tEID: {EID} {{{ElementType}}}{Environment.NewLine}" +
                                $"\t{NamedVersion}, Virtual: {VirStreamNumber}\\{VirVersionNumber}, Real: {RealStreamNumber}\\{RealVersionNumber}";
                }
                case "G":  // location, the depot-relative path of the element (default when not using a format specifier)
                    return Location;
                case "F":  // True if the element is a folder, False otherwise
                    return Folder.ToString();
                case "E":  // UNIX/Linux systems only: True if the executable bit is set, False if cleared
                    return Executable.ToString();
                case "I":  // element ID
                    return EID.ToString();
                case "T":  // element's type: dir, text, binary, ptext, elink, or slink
                    return ElementType.ToString();
                case "FS": // file size in bytes
                    return (Size == null) ? String.Empty : Size.ToString();
                case "MT": // element's modification time
                    return ModTime.ToString();
                case "H": // hierarchy type: parallel or serial
                    return HierType;
                case "V": // virtual stream\\version number designation, e.g. 5\12
                    return $"{VirStreamNumber}\\{VirVersionNumber}";
                case "R": // real stream\\version number designation, e.g. 5\12
                    return $"{RealStreamNumber}\\{RealVersionNumber}";
                case "N": // named stream\version number format, e.g. MARS_STAGE\7 or MARS_STAGE_barnyrd\24
                    return NamedVersion;
                case "L": // stream where element is located when it has (\e underlap)(\e member) or (\e overlap)(\e member) status
                    return LapStream;
                case "TB": // first time-based stream found when 'stat -s stream -o -B -fox' is used to retrieve elements with (overlap) and/or (underlap) status
                    return TimeBasedStream;
                case "S": // version's status, e.g. (kept)(member)
                    return Status;
                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 static class Stat
    {
        #region class variables
        private static List<Element> _elements = new List<Element>();
        [NonSerialized] private static readonly object _locker = new object();
        #endregion

        public static List<Element> Elements
        {
            get { return _elements; }
            private set { _elements = value; }
        }

        public static void clear()
        {
            _elements.Clear();
        }

        public static bool init(string xml)
        {
            bool ret = false; // assume failure
            try
            {
                XElement elements = XElement.Parse(xml);
                IEnumerable<XElement> query = from e in elements.Elements("element")
                                              where !e.Attribute("status").Value.Contains("no such elem")
                                              select e;
                foreach (XElement e in query)
                {
                    Element element = new Element();
                    element.Status = (string)e.Attribute("status") ?? String.Empty;
                    element.Location = (string)e.Attribute("location") ?? String.Empty;
                    string dir = (string)e.Attribute("dir") ?? String.Empty;
                    element.Folder = String.Equals(dir, "yes");
                    string exe = (string)e.Attribute("executable") ?? String.Empty;
                    element.Executable = String.Equals(exe, "yes");
                    element.EID = (int?)e.Attribute("id") ?? 0;
                    element.ElementType = e.acxType("elemType");
                    element.Size = (long?)e.Attribute("size");
                    element.ModTime = e.acxTime("modTime");
                    element.HierType = (string)e.Attribute("hierType") ?? String.Empty;
                    int ival;
                    string vir = (string)e.Attribute("Virtual") ?? String.Empty;
                    if (!String.IsNullOrEmpty(vir))
                    {
                        string[] arrVir = vir.Split('\\');
                        if (Int32.TryParse(arrVir[0], NumberStyles.Integer, null, out ival))
                            element.VirStreamNumber = ival;
                        if (Int32.TryParse(arrVir[1], NumberStyles.Integer, null, out ival))
                            element.VirVersionNumber = ival;
                    }
                    element.NamedVersion = (string)e.Attribute("namedVersion") ?? String.Empty;
                    string real = (string)e.Attribute("Real") ?? String.Empty;
                    if (!String.IsNullOrEmpty(real))
                    {
                        string[] arrReal = real.Split('\\');
                        if (Int32.TryParse(arrReal[0], NumberStyles.Integer, null, out ival))
                            element.RealStreamNumber = ival;
                        if (Int32.TryParse(arrReal[1], NumberStyles.Integer, null, out ival))
                            element.RealVersionNumber = ival;
                    }
                    element.LapStream = (string)e.Attribute("overlapStream") ?? String.Empty;
                    element.TimeBasedStream = (string)e.Attribute("timeBasisStream") ?? String.Empty;
                    lock (_locker) { _elements.Add(element); }
                }

                ret = true; // operation succeeded
            }

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

            return ret;
        }



        public static Element getElement(XElement version)
        {
            Debug.Assert(version.Name == "version", @"version.Name == ""version""");
            int? virEID = (int?)version.Attribute("eid");
            if (virEID == null) return null;

            int[] virStreamVersion = version.acxStreamVersion(RealVirtual.Virtual);
            if (virStreamVersion == null) return null;
            int[] realStreamVersion = version.acxStreamVersion(RealVirtual.Real);
            if (realStreamVersion == null) return null;

            string virStream = version.acxStreamName(RealVirtual.Virtual);
            if (virStream == null) return null;
            string realStream = version.acxStreamName(RealVirtual.Real);
            if (realStream == null) return null;

            IEnumerable<Element> query = from e in _elements
                                         where e.EID == virEID &&
                                         e.VirStreamNumber == virStreamVersion[0] && e.VirVersionNumber == virStreamVersion[1] &&
                                         e.RealStreamNumber == realStreamVersion[0] && e.RealVersionNumber == realStreamVersion[1] &&
                                         (e.NamedVersion.StartsWith(virStream) || e.NamedVersion.StartsWith(realStream))
                                         select e;
            return query.FirstOrDefault();
        }
    }
}