CaseInsensitiveString.cs

using System;
using System.Collections.Generic;
using Waher.Runtime.Collections;
 
namespace Waher.Persistence
{
    public class CaseInsensitiveString : IComparable<CaseInsensitiveString>, IComparable
    {
        private readonly string value;
        private readonly string lowerCase;
        private string upperCase;
 
        public CaseInsensitiveString(string Value)
        {
            this.value = Value;
            this.lowerCase = Value?.ToLower();
        }
 
        public string Value => this?.value;
 
        public string LowerCase => this?.lowerCase;
 
        public string UpperCase
        {
            get
            {
                if (this.upperCase is null)
                    this.upperCase = this.value?.ToUpper();
 
                return this.upperCase;
            }
        }
 
        public override string ToString()
        {
            return this.value ?? string.Empty;
        }
 
        public override int GetHashCode()
        {
            return this.lowerCase?.GetHashCode() ?? 0;
        }
 
        public override bool Equals(object obj)
        {
            if (obj is CaseInsensitiveString S)
                return this.lowerCase?.Equals(S?.lowerCase) ?? (S.lowerCase is null);
            else if (obj is string S2)
                return this.lowerCase?.Equals(S2?.ToLower()) ?? (S2 is null);
            else if (obj is null)
                return this.lowerCase is null;
            else
                return false;
        }
 
        public int CompareTo(CaseInsensitiveString other)
        {
            return this.lowerCase?.CompareTo(other.lowerCase) ?? (other.lowerCase is null ? 0 : -1);
        }
 
        public int CompareTo(object obj)
        {
            if (obj is CaseInsensitiveString S)
                return this.lowerCase?.CompareTo(S.lowerCase) ?? (S.lowerCase is null ? 0 : -1);
            else if (obj is string S2)
                return this.lowerCase?.CompareTo(S2?.ToLower()) ?? (S2 is null ? 0 : -1);
            else if (obj is null)
                return this.lowerCase is null ? 0 : 1;
            else
                return -1;
        }
 
        public static implicit operator string(CaseInsensitiveString S)
        {
            return S?.value;
        }
 
        public static implicit operator CaseInsensitiveString(string S)
        {
            return S is null ? null : new CaseInsensitiveString(S);
        }
 
        public static bool operator ==(CaseInsensitiveString S1, CaseInsensitiveString S2)
        {
            return S1?.lowerCase == S2?.lowerCase;
        }
 
        public static bool operator !=(CaseInsensitiveString S1, CaseInsensitiveString S2)
        {
            return S1?.lowerCase != S2?.lowerCase;
        }
 
        public static bool operator <(CaseInsensitiveString S1, CaseInsensitiveString S2)
        {
            return string.Compare(S1?.lowerCase, S2?.lowerCase) < 0;
        }
 
        public static bool operator >(CaseInsensitiveString S1, CaseInsensitiveString S2)
        {
            return string.Compare(S1?.lowerCase, S2?.lowerCase) > 0;
        }
 
        public static bool operator <=(CaseInsensitiveString S1, CaseInsensitiveString S2)
        {
            return string.Compare(S1?.lowerCase, S2?.lowerCase) <= 0;
        }
 
        public static bool operator >=(CaseInsensitiveString S1, CaseInsensitiveString S2)
        {
            return string.Compare(S1?.lowerCase, S2?.lowerCase) >= 0;
        }
 
        public static bool operator ==(CaseInsensitiveString S1, string S2)
        {
            return S1?.lowerCase == S2?.ToLower();
        }
 
        public static bool operator !=(CaseInsensitiveString S1, string S2)
        {
            return S1?.lowerCase != S2?.ToLower();
        }
 
        public static bool operator <(CaseInsensitiveString S1, string S2)
        {
            return string.Compare(S1?.lowerCase, S2?.ToLower()) < 0;
        }
 
        public static bool operator >(CaseInsensitiveString S1, string S2)
        {
            return string.Compare(S1?.lowerCase, S2?.ToLower()) > 0;
        }
 
        public static bool operator <=(CaseInsensitiveString S1, string S2)
        {
            return string.Compare(S1?.lowerCase, S2?.ToLower()) <= 0;
        }
 
        public static bool operator >=(CaseInsensitiveString S1, string S2)
        {
            return string.Compare(S1?.lowerCase, S2?.ToLower()) >= 0;
        }
 
        public static bool operator ==(string S1, CaseInsensitiveString S2)
        {
            return string.Compare(S1, S2?.lowerCase, true) == 0;
        }
 
        public static bool operator !=(string S1, CaseInsensitiveString S2)
        {
            return string.Compare(S1, S2?.lowerCase, true) != 0;
        }
 
        public static bool operator <(string S1, CaseInsensitiveString S2)
        {
            return string.Compare(S1, S2?.lowerCase, true) < 0;
        }
 
        public static bool operator >(string S1, CaseInsensitiveString S2)
        {
            return string.Compare(S1, S2?.lowerCase, true) > 0;
        }
 
        public static bool operator <=(string S1, CaseInsensitiveString S2)
        {
            return string.Compare(S1, S2?.lowerCase, true) <= 0;
        }
 
        public static bool operator >=(string S1, CaseInsensitiveString S2)
        {
            return string.Compare(S1, S2?.lowerCase, true) >= 0;
        }
 
        public static CaseInsensitiveString operator +(CaseInsensitiveString S1, CaseInsensitiveString S2)
        {
            return (CaseInsensitiveString)(S1?.value + S2?.value);
        }
 
        public static string operator +(CaseInsensitiveString S1, string S2)
        {
            return S1?.value + S2;
        }
 
        public static string operator +(string S1, CaseInsensitiveString S2)
        {
            return S1 + S2?.value;
        }
 
        public static readonly CaseInsensitiveString Empty = new CaseInsensitiveString(string.Empty);
 
        public CaseInsensitiveString(char[] value)
            : this(new string(value))
        {
        }
 
        public CaseInsensitiveString(char c, int count)
            : this(new string(c, count))
        {
        }
 
        public CaseInsensitiveString(char[] value, int startIndex, int length)
            : this(new string(value, startIndex, length))
        {
        }
 
        public char this[int index] => this.value[index];
 
        public int Length => this.value.Length;
 
        //
        public static int Compare(CaseInsensitiveString strA, CaseInsensitiveString strB)
        {
            return string.Compare(strA.lowerCase, strB.lowerCase);
        }
 
        public static int Compare(CaseInsensitiveString strA, int indexA, CaseInsensitiveString strB, int indexB, int length, StringComparison comparisonType)
        {
            return string.Compare(strA.lowerCase, indexA, strB.lowerCase, indexB, length, comparisonType);
        }
 
        public static int Compare(CaseInsensitiveString strA, int indexA, CaseInsensitiveString strB, int indexB, int length)
        {
            return string.Compare(strA.lowerCase, indexA, strB.lowerCase, indexB, length);
        }
 
        //
        public static int Compare(CaseInsensitiveString strA, CaseInsensitiveString strB, StringComparison comparisonType)
        {
            return string.Compare(strA.lowerCase, strB.lowerCase, comparisonType);
        }
 
        //
        public static int CompareOrdinal(CaseInsensitiveString strA, int indexA, CaseInsensitiveString strB, int indexB, int length)
        {
            return string.CompareOrdinal(strA.lowerCase, indexA, strB.lowerCase, indexB, length);
        }
 
        //
        public static int CompareOrdinal(CaseInsensitiveString strA, CaseInsensitiveString strB)
        {
            return string.CompareOrdinal(strA.lowerCase, strB.lowerCase);
        }
 
        //
        public static CaseInsensitiveString Concat<T>(IEnumerable<T> values)
        {
            return (CaseInsensitiveString)string.Concat<T>(values);
        }
 
        public static CaseInsensitiveString Concat(params CaseInsensitiveString[] values)
        {
            return (CaseInsensitiveString)string.Concat<CaseInsensitiveString>(values);
        }
 
        public static CaseInsensitiveString Concat(CaseInsensitiveString str0, CaseInsensitiveString str1)
        {
            return (CaseInsensitiveString)string.Concat(str0?.value, str1?.value);
        }
 
        public static CaseInsensitiveString Concat(CaseInsensitiveString str0, CaseInsensitiveString str1, CaseInsensitiveString str2, CaseInsensitiveString str3)
        {
            return (CaseInsensitiveString)string.Concat(str0?.value, str1?.value, str2?.value, str3?.value);
        }
 
        public static CaseInsensitiveString Concat(object arg0, object arg1, object arg2)
        {
            return (CaseInsensitiveString)string.Concat(arg0, arg1, arg2);
        }
 
        public static CaseInsensitiveString Concat(object arg0, object arg1)
        {
            return (CaseInsensitiveString)string.Concat(arg0, arg1);
        }
 
        public static CaseInsensitiveString Concat(object arg0)
        {
            return (CaseInsensitiveString)string.Concat(arg0);
        }
 
        public static CaseInsensitiveString Concat(IEnumerable<CaseInsensitiveString> values)
        {
            return Concat<CaseInsensitiveString>(values);
        }
 
        public static CaseInsensitiveString Concat(params object[] args)
        {
            return (CaseInsensitiveString)string.Concat(args);
        }
 
        public static CaseInsensitiveString Concat(CaseInsensitiveString str0, CaseInsensitiveString str1, CaseInsensitiveString str2)
        {
            return (CaseInsensitiveString)string.Concat(str0?.value, str1?.value, str2?.value);
        }
 
        public static bool Equals(CaseInsensitiveString a, CaseInsensitiveString b, StringComparison comparisonType)
        {
            return string.Equals(a?.lowerCase, b?.lowerCase, comparisonType);
        }
 
        public static bool Equals(CaseInsensitiveString a, CaseInsensitiveString b)
        {
            return string.Equals(a?.lowerCase, b?.lowerCase);
        }
 
        public static CaseInsensitiveString Format(CaseInsensitiveString format, object arg0)
        {
            return (CaseInsensitiveString)string.Format(format.lowerCase, arg0);
        }
 
        public static CaseInsensitiveString Format(IFormatProvider provider, CaseInsensitiveString format, params object[] args)
        {
            return (CaseInsensitiveString)string.Format(provider, format.lowerCase, args);
        }
 
        public static CaseInsensitiveString Format(IFormatProvider provider, CaseInsensitiveString format, object arg0, object arg1, object arg2)
        {
            return (CaseInsensitiveString)string.Format(provider, format.lowerCase, arg0, arg1, arg2);
        }
 
        public static CaseInsensitiveString Format(CaseInsensitiveString format, object arg0, object arg1)
        {
            return (CaseInsensitiveString)string.Format(format.lowerCase, arg0, arg1);
        }
 
        public static CaseInsensitiveString Format(IFormatProvider provider, CaseInsensitiveString format, object arg0, object arg1)
        {
            return (CaseInsensitiveString)string.Format(provider, format.lowerCase, arg0, arg1);
        }
 
        public static CaseInsensitiveString Format(IFormatProvider provider, CaseInsensitiveString format, object arg0)
        {
            return (CaseInsensitiveString)string.Format(provider, format.lowerCase, arg0);
        }
 
        public static CaseInsensitiveString Format(CaseInsensitiveString format, params object[] args)
        {
            return (CaseInsensitiveString)string.Format(format.lowerCase, args);
        }
 
        public static CaseInsensitiveString Format(CaseInsensitiveString format, object arg0, object arg1, object arg2)
        {
            return (CaseInsensitiveString)string.Format(format.lowerCase, arg0, arg1, arg2);
        }
 
        public static bool IsNullOrEmpty(CaseInsensitiveString value)
        {
            return string.IsNullOrEmpty(value?.value);
        }
 
        public static bool IsNullOrWhiteSpace(CaseInsensitiveString value)
        {
            return string.IsNullOrWhiteSpace(value?.value);
        }
 
        public static CaseInsensitiveString Join(CaseInsensitiveString separator, params object[] values)
        {
            return (CaseInsensitiveString)string.Join(separator?.value, values);
        }
 
        public static CaseInsensitiveString Join(CaseInsensitiveString separator, params CaseInsensitiveString[] value)
        {
            return (CaseInsensitiveString)string.Join(separator?.value, value.ToStringArray());
        }
 
        public static CaseInsensitiveString Join<T>(CaseInsensitiveString separator, IEnumerable<T> values)
        {
            return (CaseInsensitiveString)string.Join(separator?.value, values);
        }
 
        public static CaseInsensitiveString Join(CaseInsensitiveString separator, CaseInsensitiveString[] value, int startIndex, int count)
        {
            return (CaseInsensitiveString)string.Join(separator?.value, value.ToStringArray(), startIndex, count);
        }
 
        public static CaseInsensitiveString Join(CaseInsensitiveString separator, IEnumerable<CaseInsensitiveString> values)
        {
            return (CaseInsensitiveString)string.Join(separator?.value, values);
        }
 
        public bool Contains(CaseInsensitiveString value)
        {
            return this.lowerCase.Contains(value.lowerCase);
        }
 
        public void CopyTo(int sourceIndex, char[] destination, int destinationIndex, int count)
        {
            this.value.CopyTo(sourceIndex, destination, destinationIndex, count);
        }
 
        public bool EndsWith(CaseInsensitiveString value, StringComparison comparisonType)
        {
            return this.lowerCase.EndsWith(value.lowerCase, comparisonType);
        }
 
        public bool EndsWith(CaseInsensitiveString value)
        {
            return this.lowerCase.EndsWith(value.lowerCase);
        }
 
        public bool Equals(CaseInsensitiveString value)
        {
            return this.lowerCase?.Equals(value?.lowerCase) ?? value is null;
        }
 
        public bool Equals(CaseInsensitiveString value, StringComparison comparisonType)
        {
            return this.lowerCase?.Equals(value?.lowerCase, comparisonType) ?? value is null;
        }
 
        public int IndexOf(CaseInsensitiveString value, StringComparison comparisonType)
        {
            return this.lowerCase.IndexOf(value.lowerCase, comparisonType);
        }
 
        public int IndexOf(CaseInsensitiveString value, int startIndex, int count, StringComparison comparisonType)
        {
            return this.lowerCase.IndexOf(value.lowerCase, startIndex, count, comparisonType);
        }
 
        public int IndexOf(CaseInsensitiveString value, int startIndex, int count)
        {
            return this.lowerCase.IndexOf(value.lowerCase, startIndex, count);
        }
 
        public int IndexOf(CaseInsensitiveString value, int startIndex)
        {
            return this.lowerCase.IndexOf(value.lowerCase, startIndex);
        }
 
        public int IndexOf(CaseInsensitiveString value)
        {
            return this.lowerCase.IndexOf(value.lowerCase);
        }
 
        public int IndexOf(char value, int startIndex, int count)
        {
            return this.lowerCase.IndexOf(char.ToLower(value), startIndex, count);
        }
 
        public int IndexOf(char value, int startIndex)
        {
            return this.lowerCase.IndexOf(char.ToLower(value), startIndex);
        }
 
        public int IndexOf(CaseInsensitiveString value, int startIndex, StringComparison comparisonType)
        {
            return this.lowerCase.IndexOf(value.lowerCase, startIndex, comparisonType);
        }
 
        public int IndexOf(char value)
        {
            return this.lowerCase.IndexOf(char.ToLower(value));
        }
 
        public int IndexOfAny(char[] anyOf, int startIndex, int count)
        {
            return this.lowerCase.IndexOfAny(ToLower(anyOf), startIndex, count);
        }
 
        private static char[] ToLower(char[] A)
        {
            int i, c = A.Length;
 
            A = (char[])A.Clone();
 
            for (i = 0; i < c; i++)
                A[i] = char.ToLower(A[i]);
 
            return A;
        }
 
        public int IndexOfAny(char[] anyOf, int startIndex)
        {
            return this.lowerCase.IndexOfAny(ToLower(anyOf), startIndex);
        }
 
        public int IndexOfAny(char[] anyOf)
        {
            return this.lowerCase.IndexOfAny(ToLower(anyOf));
        }
 
        public int IndexOfAny(CaseInsensitiveString[] anyOf, int startIndex, int count)
        {
            int Result = int.MaxValue;
            int i, j, c = anyOf.Length;
            bool Found = false;
 
            for (i = 0; i < c; i++)
            {
                j = this.lowerCase.IndexOf(anyOf[i].lowerCase, startIndex, count);
                if (j >= 0 && j < Result)
                {
                    Result = j;
                    Found = true;
                    count = j - startIndex;
                    if (count == 0)
                        break;
                }
            }
 
            if (Found)
                return Result;
            else
                return -1;
        }
 
        public int IndexOfAny(CaseInsensitiveString[] anyOf, int startIndex)
        {
            return this.IndexOfAny(anyOf, startIndex, this.value.Length - startIndex);
        }
 
        public int IndexOfAny(CaseInsensitiveString[] anyOf)
        {
            return this.IndexOfAny(anyOf, 0, this.value.Length);
        }
 
        public CaseInsensitiveString Insert(int startIndex, CaseInsensitiveString value)
        {
            return (CaseInsensitiveString)this.value.Insert(startIndex, value?.value);
        }
 
        public int LastIndexOf(char value)
        {
            return this.lowerCase.LastIndexOf(char.ToLower(value));
        }
 
        public int LastIndexOf(char value, int startIndex)
        {
            return this.lowerCase.LastIndexOf(char.ToLower(value), startIndex);
        }
 
        public int LastIndexOf(char value, int startIndex, int count)
        {
            return this.lowerCase.LastIndexOf(char.ToLower(value), startIndex, count);
        }
 
        public int LastIndexOf(CaseInsensitiveString value)
        {
            return this.lowerCase.LastIndexOf(value.lowerCase);
        }
 
        public int LastIndexOf(CaseInsensitiveString value, int startIndex)
        {
            return this.lowerCase.LastIndexOf(value.lowerCase, startIndex);
        }
 
        public int LastIndexOf(CaseInsensitiveString value, int startIndex, int count)
        {
            return this.lowerCase.LastIndexOf(value.lowerCase, startIndex, count);
        }
 
        public int LastIndexOf(CaseInsensitiveString value, int startIndex, int count, StringComparison comparisonType)
        {
            return this.lowerCase.LastIndexOf(value.lowerCase, startIndex, count, comparisonType);
        }
 
        public int LastIndexOf(CaseInsensitiveString value, int startIndex, StringComparison comparisonType)
        {
            return this.lowerCase.LastIndexOf(value.lowerCase, startIndex, comparisonType);
        }
 
        public int LastIndexOf(CaseInsensitiveString value, StringComparison comparisonType)
        {
            return this.lowerCase.LastIndexOf(value.lowerCase, comparisonType);
        }
 
        public int LastIndexOfAny(char[] anyOf)
        {
            return this.lowerCase.LastIndexOfAny(ToLower(anyOf));
        }
 
        public int LastIndexOfAny(char[] anyOf, int startIndex)
        {
            return this.lowerCase.LastIndexOfAny(ToLower(anyOf), startIndex);
        }
 
        public int LastIndexOfAny(char[] anyOf, int startIndex, int count)
        {
            return this.lowerCase.LastIndexOfAny(ToLower(anyOf), startIndex, count);
        }
 
        public CaseInsensitiveString PadLeft(int totalWidth)
        {
            return (CaseInsensitiveString)this.value.PadLeft(totalWidth);
        }
 
        public CaseInsensitiveString PadLeft(int totalWidth, char paddingChar)
        {
            return (CaseInsensitiveString)this.value.PadLeft(totalWidth, paddingChar);
        }
 
        public CaseInsensitiveString PadRight(int totalWidth)
        {
            return (CaseInsensitiveString)this.value.PadRight(totalWidth);
        }
 
        public CaseInsensitiveString PadRight(int totalWidth, char paddingChar)
        {
            return (CaseInsensitiveString)this.value.PadRight(totalWidth, paddingChar);
        }
 
        public CaseInsensitiveString Remove(int startIndex)
        {
            return (CaseInsensitiveString)this.value.Remove(startIndex);
        }
 
        public CaseInsensitiveString Remove(int startIndex, int count)
        {
            return (CaseInsensitiveString)this.value.Remove(startIndex, count);
        }
 
        public CaseInsensitiveString Replace(CaseInsensitiveString oldValue, CaseInsensitiveString newValue)
        {
            string s = this.value;
            string s2 = this.lowerCase;
            int i = s2.IndexOf(oldValue.lowerCase);
            int c = oldValue.Length;
            int d = newValue.Length;
            int Diff = 0;
 
            while (i >= 0)
            {
                s = s.Remove(i + Diff, c);
                s = s.Insert(i + Diff, newValue?.value);
 
                i = s2.IndexOf(oldValue.lowerCase, i + c);
                Diff += d - c;
            }
 
            return (CaseInsensitiveString)s;
        }
 
        public CaseInsensitiveString Replace(char oldChar, char newChar)
        {
            string s = this.value.Replace(oldChar, newChar);
            char ch = char.ToLower(oldChar);
 
            if (ch != oldChar)
                s = s.Replace(ch, char.ToLower(newChar));
            else
                s = s.Replace(char.ToUpper(oldChar), char.ToUpper(newChar));
 
            return (CaseInsensitiveString)s;
        }
 
        public CaseInsensitiveString[] Split(params char[] separator)
        {
            return this.Split(separator, int.MaxValue, StringSplitOptions.None);
        }
 
        public CaseInsensitiveString[] Split(char[] separator, int count)
        {
            return this.Split(separator, count, StringSplitOptions.None);
        }
 
        public CaseInsensitiveString[] Split(char[] separator, int count, StringSplitOptions options)
        {
            char[] A = ToLower(separator);
            int i = this.lowerCase.IndexOfAny(A);
            int Last = -1;
            ChunkedList<CaseInsensitiveString> Result = new ChunkedList<CaseInsensitiveString>();
            string s;
 
            while (i >= 0 && count > 0)
            {
                s = this.value.Substring(Last + 1, i - Last - 1);
 
                if (options != StringSplitOptions.RemoveEmptyEntries || !string.IsNullOrEmpty(s))
                {
                    count--;
                    Result.Add((CaseInsensitiveString)s);
                }
 
                Last = i;
                i = this.lowerCase.IndexOfAny(A, i + 1);
            }
 
            if (count > 0)
            {
                s = this.value.Substring(Last + 1);
 
                if (options != StringSplitOptions.RemoveEmptyEntries || !string.IsNullOrEmpty(s))
                    Result.Add((CaseInsensitiveString)this.value.Substring(Last + 1));
            }
 
            return Result.ToArray();
        }
 
        public CaseInsensitiveString[] Split(char[] separator, StringSplitOptions options)
        {
            return this.Split(separator, int.MaxValue, options);
        }
 
        public CaseInsensitiveString[] Split(CaseInsensitiveString[] separator, int count, StringSplitOptions options)
        {
            int i = this.IndexOfAny(separator);
            int Last = -1;
            ChunkedList<CaseInsensitiveString> Result = new ChunkedList<CaseInsensitiveString>();
            string s;
 
            while (i >= 0 && count > 0)
            {
                s = this.value.Substring(Last + 1, i - Last - 1);
 
                if (options != StringSplitOptions.RemoveEmptyEntries || !string.IsNullOrEmpty(s))
                {
                    count--;
                    Result.Add((CaseInsensitiveString)s);
                }
 
                Last = i;
                i = this.IndexOfAny(separator, i + 1);
            }
 
            if (count > 0)
            {
                s = this.value.Substring(Last + 1);
 
                if (options != StringSplitOptions.RemoveEmptyEntries || !string.IsNullOrEmpty(s))
                    Result.Add((CaseInsensitiveString)this.value.Substring(Last + 1));
            }
 
            return Result.ToArray();
 
        }
 
        public CaseInsensitiveString[] Split(CaseInsensitiveString[] separator, StringSplitOptions options)
        {
            return this.Split(separator, int.MaxValue, options);
        }
 
        public bool StartsWith(CaseInsensitiveString value)
        {
            return this.lowerCase.StartsWith(value.lowerCase);
        }
 
        public bool StartsWith(CaseInsensitiveString value, StringComparison comparisonType)
        {
            return this.lowerCase.StartsWith(value.lowerCase, comparisonType);
        }
 
        public CaseInsensitiveString Substring(int startIndex, int length)
        {
            return (CaseInsensitiveString)this.value.Substring(startIndex, length);
        }
 
        public CaseInsensitiveString Substring(int startIndex)
        {
            return (CaseInsensitiveString)this.value.Substring(startIndex);
        }
 
        public char[] ToCharArray(int startIndex, int length)
        {
            return this.value.ToCharArray(startIndex, length);
        }
 
        public char[] ToCharArray()
        {
            return this.value.ToCharArray();
        }
 
        public CaseInsensitiveString Trim()
        {
            return (CaseInsensitiveString)this.value.Trim();
        }
 
        public CaseInsensitiveString Trim(params char[] trimChars)
        {
            return (CaseInsensitiveString)this.value.Trim(UpperAndLowerCases(trimChars));
        }
 
        private static char[] UpperAndLowerCases(char[] trimChars)
        {
            ChunkedList<char> A = new ChunkedList<char>();
            int i, c = trimChars.Length;
            char ch, ch2;
 
            for (i = 0; i < c; i++)
            {
                ch = trimChars[i];
                A.Add(ch);
 
                ch2 = char.ToLower(ch);
                if (ch2 != ch)
                    A.Add(ch2);
 
                ch2 = char.ToUpper(ch);
                if (ch2 != ch)
                    A.Add(ch2);
            }
 
            return A.ToArray();
        }
 
        public CaseInsensitiveString TrimEnd(params char[] trimChars)
        {
            return (CaseInsensitiveString)this.value.TrimEnd(UpperAndLowerCases(trimChars));
        }
 
        public CaseInsensitiveString TrimStart(params char[] trimChars)
        {
            return (CaseInsensitiveString)this.value.TrimStart(UpperAndLowerCases(trimChars));
        }
 
    }
}