BadLogMask.cs

Go to the documentation of this file.

namespace BadScript2.Common.Logging;
 
public class BadLogMask
{
    private static readonly Dictionary<string, ulong> s_Masks = new Dictionary<string, ulong>
    {
        {
            "None", 0
        },
        {
            "Default", 1
        },
    };
 
    public static readonly BadLogMask None = new BadLogMask(0);
 
    public static readonly BadLogMask All = new BadLogMask(~0UL);
 
    public static readonly BadLogMask Default = new BadLogMask(1);
 
 
    private readonly ulong m_Mask;
 
    private BadLogMask(ulong mask)
    {
        m_Mask = mask;
    }
 
 
    public static BadLogMask Register(string name)
    {
        ulong value = (ulong)1 << s_Masks.Count - 1;
        s_Masks.Add(name, value);
 
        return new BadLogMask(value);
    }
 
    public static implicit operator BadLogMask(ulong mask)
    {
        return new BadLogMask(mask);
    }
 
    public static implicit operator BadLogMask(string name)
    {
        switch (name)
        {
            case "None":
                return None;
            case "All":
                return All;
        }
 
        return !s_Masks.ContainsKey(name) ? Register(name) : new BadLogMask(s_Masks[name]);
    }
 
    private static bool IsPowerOfTwo(ulong number)
    {
        if (number == 0)
        {
            return false;
        }
 
        for (ulong power = 1; power > 0; power <<= 1)
        {
            // This for loop used shifting for powers of 2, meaning
            // that the value will become 0 after the last shift
            // (from binary 1000...0000 to 0000...0000) then, the 'for'
            // loop will break out.
 
            if (power == number)
            {
                return true;
            }
 
            if (power > number)
            {
                return false;
            }
        }
 
        return false;
    }
 
 
    public static BadLogMask GetMask(params BadLogMask[] masks)
    {
        return masks.Aggregate<BadLogMask, ulong>(0, (current, name) => current | name.m_Mask);
    }
 
    public static implicit operator ulong(BadLogMask mask)
    {
        return mask.m_Mask;
    }
 
    public string[] GetNames()
    {
        if (m_Mask == None.m_Mask)
        {
            return new[]
            {
                "None",
            };
        }
 
        if (m_Mask == All.m_Mask)
        {
            return new[]
            {
                "All",
            };
        }
 
        if (IsPowerOfTwo(m_Mask))
        {
            if (s_Masks.Any(x => x.Value == m_Mask))
            {
                return new[]
                {
                    s_Masks.First(x => x.Value == m_Mask).Key,
                };
            }
 
            return Array.Empty<string>();
        }
 
        List<string> names = (from kvp in s_Masks where kvp.Value != 0 && (kvp.Value & m_Mask) == kvp.Value select kvp.Key).ToList();
 
        return names.Count == 0 ? Array.Empty<string>() : names.ToArray();
    }
 
    public static implicit operator string(BadLogMask mask)
    {
        return string.Join(" ", mask.GetNames());
    }
 
    public bool IsContainedIn(BadLogMask other)
    {
        return (m_Mask & other.m_Mask) == m_Mask;
    }
 
    public bool IsExactly(BadLogMask other)
    {
        return m_Mask == other.m_Mask;
    }
 
    public bool Contains(BadLogMask mask)
    {
        return mask.IsContainedIn(this);
    }
 
    public override string ToString()
    {
        return this;
    }
}