AcProperties.cs

Go to the documentation of this file.

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

namespace AcUtils
{
    #region enums

    public enum PropKind
    {
        principal,
        stream
    }
    #endregion

    [Serializable]
    public sealed class AcProperty : IFormattable, IEquatable<AcProperty>, IComparable<AcProperty>, IComparable
    {
        #region class variables
        private PropKind _kind; // type of property, either "principal" or "stream"
        private AcDepot _depot; // depot when Kind is a stream, otherwise null
        private int _id; // stream or principal ID number
        private string _name; // stream or principal name
        private string _propName; // property name
        private string _propValue; // property value
        #endregion

        internal AcProperty() { }

        #region Equality comparison

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

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

        #region Order comparison


        public int CompareTo(AcProperty other)
        {
            int result = 0;
            if (AcProperty.ReferenceEquals(this, other))
                result = 0;
            else
            {
                if (Depot != null && other.Depot != null)
                    result = Depot.CompareTo(other.Depot);
                if (result == 0)
                    result = String.Compare(Name, other.Name);
                if (result == 0)
                    result = String.Compare(PropName, other.PropName);
            }

            return result;
        }

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

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

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

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

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

        public string PropName
        {
            get { return _propName ?? String.Empty; }
            internal set { _propName = value; }
        }

        public string PropValue
        {
            get { return _propValue ?? String.Empty; }
            internal set { _propValue = 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": //  Depot stream/principal name along with the name-value property pair (default when not using a format specifier).
                {
                    string text;
                    if (_depot == null)
                        text = $"{Name} ({ID}), {PropName}={PropValue}";
                    else
                        text = $"{Depot}, {Name} ({ID}), {PropName}={PropValue}";
                    return text;
                }
                case "K": // type of the property, either "principal" or "stream"
                    return Kind.ToString();
                case "D": // depot name when property type is a stream, otherwise an empty string
                    return (Depot == null) ? String.Empty : Depot.ToString();
                case "I": // stream or principal ID number
                    return ID.ToString();
                case "N": // stream or principal name
                    return Name;
                case "PN": // property name
                    return PropName;
                case "PV": // property value
                    return PropValue;
                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 AcProperties : List<AcProperty>
    {
        #region class variables
        [NonSerialized] private readonly object _locker = new object();
        #endregion

        #region object construction:


        public AcProperties() { }


        public async Task<bool> initAsync(AcDepot depot, AcStream stream = null, bool includeHidden = false)
        {
            bool ret = false; // assume failure
            try
            {
                string cmd = null;
                if (stream != null && includeHidden)
                    cmd = $@"getproperty -fix -s ""{stream}""";
                else if (stream != null && !includeHidden)
                    cmd = $@"getproperty -fx -s ""{stream}""";
                else if (includeHidden) // request is for all streams in depot including those that are hidden
                    cmd = $@"getproperty -fix -ks -p ""{depot}""";
                else  // request is for all streams except those that are hidden
                    cmd = $@"getproperty -fx -ks -p ""{depot}""";

                AcResult r = await AcCommand.runAsync(cmd).ConfigureAwait(false);
                if (r != null && r.RetVal == 0)
                {
                    XElement xml = XElement.Parse(r.CmdResult);
                    foreach (XElement e in xml.Elements("property"))
                    {
                        AcProperty property = new AcProperty();
                        string kind = (string)e.Attribute("kind");
                        property.Kind = (PropKind)Enum.Parse(typeof(PropKind), kind);
                        property.Depot = depot;
                        property.ID = (int)e.Attribute("streamNumber");
                        property.Name = (string)e.Attribute("streamName");
                        property.PropName = (string)e.Attribute("propertyName");
                        property.PropValue = (string)e;
                        lock (_locker) { Add(property); }
                    }

                    ret = true; // operation succeeded
                }
            }

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

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

            return ret;
        }


        public async Task<bool> initAsync(string prncpl = null, bool includeHidden = false)
        {
            bool ret = false; // assume failure
            try
            {
                string cmd = null;
                if (!String.IsNullOrEmpty(prncpl) && includeHidden)
                    cmd = $@"getproperty -fix -u ""{prncpl}""";
                else if (!String.IsNullOrEmpty(prncpl) && !includeHidden)
                    cmd = $@"getproperty -fx -u ""{prncpl}""";
                else if (includeHidden) // request is for all principals including those that are hidden
                    cmd = "getproperty -fix -ku";
                else // request is for all principals except those that are hidden
                    cmd = "getproperty -fx -ku";

                AcResult r = await AcCommand.runAsync(cmd).ConfigureAwait(false);
                if (r != null && r.RetVal == 0)
                {
                    XElement xml = XElement.Parse(r.CmdResult);
                    foreach (XElement e in xml.Elements("property"))
                    {
                        AcProperty property = new AcProperty();
                        string kind = (string)e.Attribute("kind");
                        property.Kind = (PropKind)Enum.Parse(typeof(PropKind), kind);
                        property.ID = (int)e.Attribute("principalNumber");
                        property.Name = (string)e.Attribute("principalName");
                        property.PropName = (string)e.Attribute("propertyName");
                        property.PropValue = (string)e;
                        lock (_locker) { Add(property); }
                    }

                    ret = true; // operation succeeded
                }
            }

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

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

            return ret;
        }
        #endregion
    }
}