/// <summary> /// Compares this string to another UTF32String. /// </summary> /// <param name="obj">The other UTF32String to compare this string to.</param> /// <returns> /// <0 if this string <> obj; 0 if this==object; >0 if this string > obj, /// with the relation defines in a culture-insensitive way in lexicographic order. /// </returns> public int CompareTo(object obj) { if (obj == null) { return(1); } UTF32String other = obj as UTF32String; if (other == null) { throw new ArgumentException("Can only compare Utf32Strings", nameof(obj)); } int minLength = Math.Min(Length, other.Length); for (int i = 0; i < minLength; i++) { int result = this[i] - other[i]; if (result != 0) { return(result); } } // Both strings are the same for all the characters in the shorter // one. The longer one is now greater, or they're the same. return(Length - other.Length); }
/// <summary> /// Finds the index of another UTF32String within this one, /// starting at the specified position and considering the /// specified number of positions. /// </summary> /// <param name="value">Value to find</param> /// <param name="start">First position to consider when finding value within this UTF32String</param> /// <param name="count">Number of positions to consider</param> /// <returns>The index of value within this string, or -1 if it isn't found</returns> public int IndexOf(UTF32String value, int start, int count) { _characters.Length.ValidateRange(start, ref count); if (_characters.Length == 0 || count == 0) { return(-1); } for (int i = start; i < start + count; i++) { if (i + value.Length > Length) { return(-1); } int j; for (j = 0; j < value.Length; j++) { if (_characters[i + j] != value._characters[j]) { break; } } if (j == value.Length) { return(i); } } return(-1); }
/// <summary> /// Returns a concatenation of the given strings. /// </summary> /// <param name="strA">The first string</param> /// <param name="strB">The second string</param> /// <returns>A string consisting of the first string followed by the second</returns> public static UTF32String Concat(UTF32String strA, UTF32String strB) { return(Concat(new[] { strA, strB })); }
/// <summary> /// Finds the index of another UTF32String within this one, /// starting at the specified position. /// </summary> /// <param name="value">Value to find</param> /// <param name="start">First position to consider when finding value within this UTF32String</param> /// <returns>The index of value within this string, or -1 if it isn't found</returns> public int IndexOf(UTF32String value, int start) { if (start < 0 || start > Length) { throw new ArgumentOutOfRangeException(nameof(start), "start must lie within the string bounds"); } return(IndexOf(value, start, Length - start)); }
/// <summary> /// Returns a concatenation of the given strings. /// </summary> /// <param name="strA">The first string</param> /// <param name="strB">The second string</param> /// <param name="strC">The third string</param> /// <param name="strD">The fourth string</param> /// <returns> /// A string consisting of the first string /// followed by the second, followed by the third, /// followed by the fourth /// </returns> public static UTF32String Concat(UTF32String strA, UTF32String strB, UTF32String strC, UTF32String strD) { return(Concat(new[] { strA, strB, strC, strD })); }
/// <summary> /// Compares the two specified strings. /// </summary> /// <param name="strA">The first string to compare</param> /// <param name="strB">The second string to compare</param> /// <returns> /// 0 if both strings are null or they are equal; a negative number if strA == null or /// is lexicographically before strB; a positive number otherwise /// </returns> public static int Compare(UTF32String strA, UTF32String strB) { return(ReferenceEquals(strA, strB) ? 0 : (object)strA == null || (object)strB == null ? (object)strA == null ? -1 : 1 : strA.CompareTo(strB)); }
/// <summary> /// Compares one string with another for equality. /// </summary> /// <param name="strA">The first string to compare</param> /// <param name="strB">The second string to compare</param> /// <returns>true if the strings are equivalent; false otherwise</returns> public static bool Equals(UTF32String strA, UTF32String strB) { return(Compare(strA, strB) == 0); }
/// <summary> /// Compares two UTF-32 strings (in a culture-insensitive manner) for equality. /// </summary> /// <param name="other">The other string to compare this one to.</param> /// <returns>Whether or not this string is equal to the other one.</returns> public bool Equals(UTF32String other) { return(ReferenceEquals(this, other) || CompareTo(other) == 0); }
/// <summary> /// Finds the index of another UTF32String within this one. /// </summary> /// <param name="value">Value to find</param> /// <returns>The index of value within this string, or -1 if it isn't found</returns> public int IndexOf(UTF32String value) { return(IndexOf(value, 0, Length)); }
/// <summary> /// Returns whether or not this UTF-32 string is equal to another object. /// </summary> /// <param name="obj">The object to compare this UTF-32 string to.</param> /// <returns>Whether or not this object is equal to the other one.</returns> public override bool Equals(object obj) { UTF32String other = obj as UTF32String; return(other != null && Equals(other)); }