Extensions.cs

Go to the documentation of this file.

using Mercury.Nucleus.Collections;
using Mercury.Scanning;
using System;
using System.Collections.Generic;
using System.Text;

namespace Mercury
{
    public static class Extensions
    {
        //--[  Private stuff  ]------------------------------------------------

        private static Tokenizer defaultTokenizer;
        private static Random    rgen;
        private static string    rchars;

        #region [  UniqueCharSeqGenerator  ]

        private static class UniqueCharSeqGenerator
        {
            private static ulong  nextid;
            private static char[] chrarr;

            static UniqueCharSeqGenerator()
            { 
                nextid = 0L;
                List<char> chars = new List<char>();

                for (char c = '0'; c <= '9'; ++c) chars.Add(c);
                for (char c = 'a'; c <= 'z'; ++c) chars.Add(c);
                for (char c = 'A'; c <= 'Z'; ++c) chars.Add(c);

                chrarr = chars.ToArray();
            }

            public static string GetNextSeq()
            {
                var id = nextid++;
                var cn = (ulong) chrarr.Length;
                var sb = new StringBuilder();

                bool  init = true;
                ulong rm;
                do
                {
                    if      (init)    init = false;
                    else if (id != 0) --id;

                    rm  = id % cn;
                    id /= cn;
                    sb.Insert(0, chrarr[rm]);
                } while (id != 0L);

                return sb.ToString();
            }
        }

        #endregion

        //--[  Static constructor  ]-------------------------------------------

        static Extensions()
        {
            defaultTokenizer = new Tokenizer();
            rgen             = new Random();
            StringBuilder sb = new StringBuilder();

            for (char c = 'a'; c < 'z'; ++c)
                sb.Append(c).Append(char.ToUpperInvariant(c));

            rchars = sb.ToString();
        }

        //--[  Global extensions  ]--------------------------------------------

        public static bool Power2(int x)
        { return (x != 0) && (x & (x - 1)) == 0; }

        public static int IntegralPow(int a, uint exp)
        {
            int ret = 1;

            while (exp != 0)
            {
                if ((exp & 1) == 1) ret *= a;
                a   *=  a;
                exp >>= 1;
            }

            return ret;
        }

        public static string UniqueCharSeq()
        { return UniqueCharSeqGenerator.GetNextSeq(); }

        public static string RandomString(int length, string init = "")
        {
            StringBuilder sb = new StringBuilder(init, init.Length + length);

            for (int ix = 0; ix < length; ++ix)
                sb.Append(rchars[rgen.Next(rchars.Length)]);

            return sb.ToString();
        }

        public static string RandomString(string pattern)
        {
            StringBuilder sb = new StringBuilder(pattern.Length);
            
            for (int ix = 0; ix < pattern.Length; ++ix)
                switch (pattern[ix])
                {
                    case '.': sb.Append(rchars[rgen.Next(rchars.Length)]);    break;
                    case '%': sb.Append(rgen.Next(0, 9));                     break;
                    case '*': sb.Append(UniqueCharSeqGenerator.GetNextSeq()); break;
                    default:  sb.Append(pattern[ix]);                         break;
                }

            return sb.ToString();
        }

        //--[  Extensions  ]---------------------------------------------------

        #region [  String             ]

        public static IList<Token> Tokenize(this string src)
        { return defaultTokenizer.Tokenize(src); }

        public static string Unescape(this string src)
        {
            int start = src.IndexOf('\\');
            if (start == -1)
                return src;

            StringBuilder sb = new StringBuilder(src, 0, start, src.Length - 1);
            for(int ix = start; ix < src.Length; ++ix)
            {
                if (src[ix] != '\\')
                    sb.Append(src[ix]);
            }

            return sb.ToString();
        }

        #endregion

        #region [  IEnumerable        ]

        public static IMultiDictionary<TKey, TValue> ToMultiDictionary<TSource, TKey, TValue>(
            this IEnumerable<TSource> source, 
            Func<TSource, TKey>       keySelector,
            Func<TSource, TValue>     valueSelector)
        {
            var temp = new ListMultiDictionary<TKey, TValue>();

            foreach (TSource value in source)
                temp.Add(keySelector(value), valueSelector(value));

            return temp;
        }

        public static IMultiDictionary<TKey, TSource> ToMultiDictionary<TSource, TKey>(
            this IEnumerable<TSource> source,
            Func<TSource, TKey>       keySelector)
        { return ToMultiDictionary(source, keySelector, x => x); }

        #endregion

        #region [  IReadOnlyList      ]

        public static T ElementAtOrLast<T>(this IReadOnlyList<T> source, int index)
        { return index >= source.Count ? source[source.Count - 1] : source[index]; }

        #endregion

    }
}