Showing the changes to Source/Libraries/GSF.Core.Shared/StringExtensions.cs (1 of 4 files). Show all
Unified · Split
| @@ -1666,5 +1666,444 @@ namespace GSF · 1665 unmodified lines | ||
| 1666 | 1666 | { |
| 1667 | 1667 | return Uri.EscapeDataString(value); |
| 1668 | 1668 | } |
| 1669 | + | |
| 1670 | + //********** New methods July 2017, To Be Tested ******************** | |
| 1671 | + | |
| 1672 | + /// <summary> | |
| 1673 | + /// Removes one or more instances of a specified string from the beginning of a string. | |
| 1674 | + /// </summary> | |
| 1675 | + /// <param name="value">The string to process</param> | |
| 1676 | + /// <param name="stringToRemove">The string to remove</param> | |
| 1677 | + /// <param name="matchCase">Set to <c>false</c> for case insensitive search</param> | |
| 1678 | + /// <returns>A string with <paramref name="stringToRemove"/> deleted from the beginning</returns> | |
| 1679 | + public static string RemoveLeadingString(this string value, string stringToRemove, bool matchCase = true) | |
| 1680 | + { | |
| 1681 | + if (string.IsNullOrEmpty(value)) | |
| 1682 | + return string.Empty; | |
| 1683 | + | |
| 1684 | + if (string.IsNullOrEmpty(stringToRemove)) | |
| 1685 | + return value; | |
| 1686 | + | |
| 1687 | + StringComparison scCase = (matchCase) ? StringComparison.Ordinal : StringComparison.OrdinalIgnoreCase; | |
| 1688 | + | |
| 1689 | + int i = value.IndexOf(stringToRemove, scCase); | |
| 1690 | + if (i < 0) | |
| 1691 | + return value; //handle the "do nothing" case quickly | |
| 1692 | + | |
| 1693 | + while (value.StartsWith(stringToRemove, scCase)) | |
| 1694 | + { | |
| 1695 | + if (value.Length <= stringToRemove.Length) | |
| 1696 | + return string.Empty; | |
| 1697 | + | |
| 1698 | + value = value.Substring(stringToRemove.Length); | |
| 1699 | + } | |
| 1700 | + | |
| 1701 | + return value; | |
| 1702 | + } | |
| 1703 | + | |
| 1704 | + /// <summary> | |
| 1705 | + /// Removes one or more instances of a specified char from the beginning of a string. | |
| 1706 | + /// </summary> | |
| 1707 | + /// <param name="value">The string to process</param> | |
| 1708 | + /// <param name="charToRemove">The char to remove</param> | |
| 1709 | + /// <param name="matchCase">Set to <c>false</c> for case insensitive search</param> | |
| 1710 | + /// <returns>A string with <paramref name="charToRemove"/> deleted from the beginning</returns> | |
| 1711 | + public static string RemoveLeadingString(this string value, char charToRemove, bool matchCase = true) | |
| 1712 | + { | |
| 1713 | + | |
| 1714 | + if (string.IsNullOrEmpty(value)) | |
| 1715 | + return string.Empty; | |
| 1716 | + | |
| 1717 | + if (charToRemove == 0) | |
| 1718 | + return value; | |
| 1719 | + | |
| 1720 | + string result = value; | |
| 1721 | + if (!matchCase) | |
| 1722 | + { | |
| 1723 | + value = value.ToLower(); | |
| 1724 | + charToRemove = charToRemove.ToLower(); | |
| 1725 | + } | |
| 1726 | + | |
| 1727 | + //handle the "do nothing" case quickly | |
| 1728 | + if (value[0] != charToRemove) return result; | |
| 1729 | + | |
| 1730 | + for (int i = 1; i < value.Length; i++) | |
| 1731 | + { | |
| 1732 | + if (value[i] != charToRemove) | |
| 1733 | + { | |
| 1734 | + return result.Substring(i - 1); | |
| 1735 | + } | |
| 1736 | + } | |
| 1737 | + //all the characters are to be removed. | |
| 1738 | + return string.Empty; | |
| 1739 | + } | |
| 1740 | + | |
| 1741 | + /// <summary> | |
| 1742 | + /// Assures that numeric value is a well formed number | |
| 1743 | + /// Adds a leading zero in front of a decimal, if present | |
| 1744 | + /// </summary> | |
| 1745 | + /// <param name="value">The string to process</param> | |
| 1746 | + /// <param name = "AssureParseDouble">Set to TRUE to assure that value parses to Double</param> | |
| 1747 | + /// <returns>A string with deleted from the beginning</returns> | |
| 1748 | + /// <remarks>Note: AssureParseDouble also removes trailing zeros following a decimal which implies loss of precision in the value</remarks> | |
| 1749 | + public static string RemoveLeadingZeros(this string value, bool AssureParseDouble = false) | |
| 1750 | + { | |
| 1751 | + if (string.IsNullOrEmpty(value)) | |
| 1752 | + return "0"; | |
| 1753 | + | |
| 1754 | + value = value.Trim(); | |
| 1755 | + | |
| 1756 | + if (value.Length == 0) | |
| 1757 | + return "0"; | |
| 1758 | + | |
| 1759 | + if (AssureParseDouble) | |
| 1760 | + { | |
| 1761 | + double test = 0.0; | |
| 1762 | + if (!double.TryParse(value, out test)) | |
| 1763 | + return "0"; | |
| 1764 | + | |
| 1765 | + return test.ToString(); | |
| 1766 | + } | |
| 1767 | + | |
| 1768 | + bool isNeg = false; | |
| 1769 | + | |
| 1770 | + if (value.Substring(0, 1) == "-") | |
| 1771 | + { | |
| 1772 | + isNeg = true; | |
| 1773 | + value = value.Substring(1); | |
| 1774 | + } | |
| 1775 | + | |
| 1776 | + while (value.Substring(0, 1) == "0") | |
| 1777 | + { | |
| 1778 | + if (value.Length <= 1) | |
| 1779 | + return "0"; | |
| 1780 | + | |
| 1781 | + value = value.Substring(1); | |
| 1782 | + } | |
| 1783 | + | |
| 1784 | + if (value.Substring(0, 1) == ".") | |
| 1785 | + value = "0" + value; | |
| 1786 | + | |
| 1787 | + if (isNeg && value != "0.0") | |
| 1788 | + value = "-" + value; | |
| 1789 | + | |
| 1790 | + return value; | |
| 1791 | + } | |
| 1792 | + | |
| 1793 | + /// <summary> | |
| 1794 | + /// Removes one or more instances of a string from the end of a string | |
| 1795 | + /// </summary> | |
| 1796 | + /// <param name="value">The string to process</param> | |
| 1797 | + /// <param name="stringToRemove">The string to remove</param> | |
| 1798 | + /// <param name="matchCase">Set to <c>false</c> for case insensitive search</param> | |
| 1799 | + /// <returns>A string with <paramref name="stringToRemove"/> deleted from the end</returns> | |
| 1800 | + public static string RemoveTrailingString(this string value, string stringToRemove, bool matchCase = true) | |
| 1801 | + { | |
| 1802 | + if (string.IsNullOrEmpty(value)) | |
| 1803 | + return string.Empty; | |
| 1804 | + | |
| 1805 | + if (string.IsNullOrEmpty(stringToRemove)) | |
| 1806 | + return value; | |
| 1807 | + | |
| 1808 | + StringComparison scCase = (matchCase) ? StringComparison.Ordinal : StringComparison.OrdinalIgnoreCase; | |
| 1809 | + | |
| 1810 | + int i = value.IndexOf(stringToRemove, scCase); | |
| 1811 | + | |
| 1812 | + if (i < 0) | |
| 1813 | + return value; //handle the "do nothing" case quickly | |
| 1814 | + | |
| 1815 | + while (value.EndsWith(stringToRemove, scCase)) | |
| 1816 | + { | |
| 1817 | + if (value.Length <= stringToRemove.Length) | |
| 1818 | + return string.Empty; | |
| 1819 | + | |
| 1820 | + value = value.Substring(0, value.Length - stringToRemove.Length); | |
| 1821 | + } | |
| 1822 | + | |
| 1823 | + return value; | |
| 1824 | + } | |
| 1825 | + | |
| 1826 | + /// <summary> | |
| 1827 | + /// Removes one or more instances of a character from the end of a string | |
| 1828 | + /// </summary> | |
| 1829 | + /// <param name="value">The string to process</param> | |
| 1830 | + /// <param name="charToRemove">The char to remove</param> | |
| 1831 | + /// <param name="matchCase">Set to <c>false</c> for case insensitive search</param> | |
| 1832 | + /// <returns>A string with <paramref name="charToRemove"/> deleted from the end</returns> | |
| 1833 | + public static string RemoveTrailingString(this string value, char charToRemove, bool matchCase = true) | |
| 1834 | + { | |
| 1835 | + if (string.IsNullOrEmpty(value)) | |
| 1836 | + return string.Empty; | |
| 1837 | + | |
| 1838 | + if (charToRemove == 0) | |
| 1839 | + return value; | |
| 1840 | + | |
| 1841 | + string result = value; | |
| 1842 | + if (!matchCase) | |
| 1843 | + { | |
| 1844 | + value = value.ToLower(); | |
| 1845 | + charToRemove = charToRemove.ToLower(); | |
| 1846 | + } | |
| 1847 | + | |
| 1848 | + //handle the "do nothing" case quickly | |
| 1849 | + if (value[value.Length - 1] != charToRemove) return result; | |
| 1850 | + | |
| 1851 | + for (int i = value.Length - 1; i > -1; i--) | |
| 1852 | + { | |
| 1853 | + if (value[i] != charToRemove) | |
| 1854 | + { | |
| 1855 | + return result.Substring(0, i + 1); | |
| 1856 | + } | |
| 1857 | + } | |
| 1858 | + //all the characters are to be removed. | |
| 1859 | + return string.Empty; | |
| 1860 | + } | |
| 1861 | + | |
| 1862 | + /// <summary> | |
| 1863 | + /// Returns a string consisting of a specified number of characters from the end of a string "to the left" | |
| 1864 | + /// </summary> | |
| 1865 | + /// <param name="value">The string to process</param> | |
| 1866 | + /// <param name="length">The number of characters from the end of the string to return</param> | |
| 1867 | + /// <returns>A string of length <paramref name="length" /></returns> | |
| 1868 | + public static string SubstringEnd(this string value, int length) | |
| 1869 | + { | |
| 1870 | + if (string.IsNullOrEmpty(value) || length <= 0) | |
| 1871 | + return string.Empty; | |
| 1872 | + | |
| 1873 | + if (value.Length <= length) | |
| 1874 | + return value; | |
| 1875 | + | |
| 1876 | + return value.Substring(value.Length - length); | |
| 1877 | + } | |
| 1878 | + | |
| 1879 | + /// <summary> | |
| 1880 | + /// Returns a string consisting of a specified number of characters to the left (previous chars) from the provided startIndex | |
| 1881 | + /// </summary> | |
| 1882 | + /// <param name="value">The string to process</param> | |
| 1883 | + /// <param name="endIndex">The index in <paramref name="value" /> at the end of the desired returned string.</param> | |
| 1884 | + /// <param name="length">The number of characters from the <paramref name="endIndex" /> of the string to return</param> | |
| 1885 | + /// <returns>A string to the left of <paramref name="endIndex" /> of length up to <paramref name="length" /> </returns> | |
| 1886 | + public static string SubstringPrevious(this string value, int endIndex, int length) | |
| 1887 | + { | |
| 1888 | + if (string.IsNullOrEmpty(value) || endIndex < 0 || length <= 0) | |
| 1889 | + return string.Empty; | |
| 1890 | + | |
| 1891 | + if (endIndex > value.Length - 1) | |
| 1892 | + return string.Empty; | |
| 1893 | + | |
| 1894 | + int startIndex = endIndex - length + 1; | |
| 1895 | + | |
| 1896 | + if (startIndex < 0) | |
| 1897 | + startIndex = 0; | |
| 1898 | + | |
| 1899 | + return value.Substring(startIndex, endIndex - startIndex + 1); | |
| 1900 | + } | |
| 1901 | + | |
| 1902 | + /// <summary> | |
| 1903 | + /// Searches a string from right to left for the next instance of a specified string. | |
| 1904 | + /// </summary> | |
| 1905 | + /// <param name="value">Input string to process.</param> | |
| 1906 | + /// <param name="testString">The string to find.</param> | |
| 1907 | + /// <param name="startIndex">The index in <paramref name="value"/> from which to begin looking for <paramref name="testString"/>. Typically length of <paramref name="value"/> minus 1."</param> | |
| 1908 | + /// <returns>The start (or left most) index of <paramref name="testString"/> within <paramref name="value"/> or (-1) if not found.</returns> | |
| 1909 | + public static int IndexOfPrevious(this string value, string testString, int startIndex = 0) | |
| 1910 | + { | |
| 1911 | + if (string.IsNullOrEmpty(value)) | |
| 1912 | + return -1; | |
| 1913 | + | |
| 1914 | + if (string.IsNullOrEmpty(testString)) | |
| 1915 | + return -1; | |
| 1916 | + | |
| 1917 | + if (startIndex < 0) | |
| 1918 | + return -1; | |
| 1919 | + | |
| 1920 | + if (startIndex > value.Length - 1 || startIndex - testString.Length + 1 < 0) | |
| 1921 | + { | |
| 1922 | + //return -1; | |
| 1923 | + throw new ArgumentException("IndexOfPrevious startIndex Invalid " + startIndex.ToString()); | |
| 1924 | + } | |
| 1925 | + | |
| 1926 | + //this is the fastest way to do this | |
| 1927 | + string s = value.Reverse(); | |
| 1928 | + string v = testString.Reverse(); | |
| 1929 | + int i = s.IndexOf(v, s.Length - startIndex - 1); | |
| 1930 | + | |
| 1931 | + if (i > -1) | |
| 1932 | + return s.Length - i - testString.Length; | |
| 1933 | + | |
| 1934 | + return -1; | |
| 1935 | + } | |
| 1936 | + | |
| 1937 | + /// <summary> | |
| 1938 | + /// Searches a string from right to left for the next instance of a specified character. | |
| 1939 | + /// </summary> | |
| 1940 | + /// <param name="value">Input string to process.</param> | |
| 1941 | + /// <param name="testChar">The char to find.</param> | |
| 1942 | + /// <param name="startIndex">The index in <paramref name="value"/> from which to begin looking for <paramref name="testChar"/>. Typically length of <paramref name="value"/> minus 1."</param> | |
| 1943 | + /// <returns>The index of <paramref name="testChar"/> within <paramref name="value"/> or (-1) if not found.</returns> | |
| 1944 | + public static int IndexOfPrevious(this string value, char testChar, int startIndex = 0) | |
| 1945 | + { | |
| 1946 | + if (string.IsNullOrEmpty(value)) | |
| 1947 | + return -1; | |
| 1948 | + | |
| 1949 | + if (testChar == 0) | |
| 1950 | + return -1; | |
| 1951 | + | |
| 1952 | + if (startIndex < 0) | |
| 1953 | + return -1; | |
| 1954 | + | |
| 1955 | + if (startIndex > value.Length - 1) | |
| 1956 | + { | |
| 1957 | + throw new ArgumentException("IndexOfPrevious startIndex Invalid " + startIndex.ToString()); | |
| 1958 | + } | |
| 1959 | + | |
| 1960 | + for (int j = startIndex; j > -1; j--) | |
| 1961 | + { | |
| 1962 | + if (value[j] == testChar) | |
| 1963 | + return j; | |
| 1964 | + } | |
| 1965 | + return -1; | |
| 1966 | + } | |
| 1967 | + | |
| 1968 | + /// <summary> | |
| 1969 | + /// Finds the first index that is NOT included in testChars | |
| 1970 | + /// </summary> | |
| 1971 | + /// <param name="value">String to process</param> | |
| 1972 | + /// <param name="anyOf">the characters use to test</param> | |
| 1973 | + /// <param name="startIndex">the index at which to begin testing <paramref name="value"/></param> | |
| 1974 | + /// <returns>The first index of a character NOT included in <paramref name="anyOf"/>. </returns> | |
| 1975 | + public static int IndexOfNot(this string value, char[] anyOf, int startIndex = 0) | |
| 1976 | + { | |
| 1977 | + if (string.IsNullOrEmpty(value)) | |
| 1978 | + return -1; | |
| 1979 | + | |
| 1980 | + if (anyOf == null || anyOf[0] == 0) | |
| 1981 | + return -1; | |
| 1982 | + | |
| 1983 | + if (startIndex >= value.Length) | |
| 1984 | + return -1; | |
| 1985 | + | |
| 1986 | + for (int i = startIndex; i < value.Length; i++) | |
| 1987 | + { | |
| 1988 | + if (value.IndexOfAny(anyOf) == -1) | |
| 1989 | + return i; | |
| 1990 | + } | |
| 1991 | + | |
| 1992 | + return -1; | |
| 1993 | + } | |
| 1994 | + | |
| 1995 | + /// <summary> | |
| 1996 | + /// Counts the total number of the occurrences of string within a string | |
| 1997 | + /// </summary> | |
| 1998 | + /// <param name="value">Input string to process.</param> | |
| 1999 | + /// <param name="testString">String to be counted.</param> | |
| 2000 | + /// <param name="startIndex">The index at which to begin <paramref name="value"/></param> | |
| 2001 | + /// <param name="matchCase">Set to <c>false</c> for case insensitive search</param> | |
| 2002 | + /// <returns>Total number of the occurrences of <paramref name="testString" /> in the given string.</returns> | |
| 2003 | + public static int StringCount(this string value, string testString, int startIndex = 0, bool matchCase = true) | |
| 2004 | + { | |
| 2005 | + if (string.IsNullOrEmpty(value)) | |
| 2006 | + return 0; | |
| 2007 | + | |
| 2008 | + //error - ambiguous safe case | |
| 2009 | + if (startIndex < 0) | |
| 2010 | + return 0; | |
| 2011 | + | |
| 2012 | + if (startIndex >= value.Length) | |
| 2013 | + { | |
| 2014 | + throw new ArgumentException("StringCount startIndex Invalid " + startIndex.ToString()); | |
| 2015 | + } | |
| 2016 | + | |
| 2017 | + if (string.IsNullOrEmpty(testString)) | |
| 2018 | + return 0; | |
| 2019 | + | |
| 2020 | + int total = 0; | |
| 2021 | + StringComparison scCase = (matchCase) ? StringComparison.Ordinal : StringComparison.OrdinalIgnoreCase; | |
| 2022 | + int k = value.IndexOf(testString, startIndex, scCase); | |
| 2023 | + | |
| 2024 | + while (k > -1) | |
| 2025 | + { | |
| 2026 | + total++; | |
| 2027 | + k = value.IndexOf(testString, k + testString.Length, scCase); | |
| 2028 | + } | |
| 2029 | + return total; | |
| 2030 | + } | |
| 2031 | + | |
| 2032 | + /// <summary> | |
| 2033 | + /// Unwraps quotes similar to Excel. However, a little more predictable for unusual edge cases. | |
| 2034 | + /// </summary> | |
| 2035 | + /// <param name="value">The string to process</param> | |
| 2036 | + /// <param name="quoteChar">The quote char to use. Default is double quote. Due to trimming, quoteChar of whitespace is not allowed.</param> | |
| 2037 | + /// <remarks> | |
| 2038 | + /// To remove all quote chars at beginning and end of a string regardless of match use .Trim('\"') It's faster. | |
| 2039 | + /// Three consecutive quotes assures a singe quote char in output. | |
| 2040 | + /// </remarks> | |
| 2041 | + /// <returns>The sent string with matched surrounding double quotes removed.</returns> | |
| 2042 | + public static string quoteUnwrap(this string value, char quoteChar = '\"') | |
| 2043 | + { | |
| 2044 | + if (string.IsNullOrEmpty(value)) | |
| 2045 | + return string.Empty; | |
| 2046 | + | |
| 2047 | + string s = value.Trim(); | |
| 2048 | + if (s.Length <= 1) | |
| 2049 | + return value; | |
| 2050 | + | |
| 2051 | + if (quoteChar == ' ') | |
| 2052 | + throw new ArgumentOutOfRangeException("quoteChar cannot be space (Character 32)."); | |
| 2053 | + | |
| 2054 | + string assuredQuote = new string(quoteChar, 3); | |
| 2055 | + const char marker = (char)2; | |
| 2056 | + string markerString = new string(marker, 1); | |
| 2057 | + string quoteString = new string(quoteChar, 1); | |
| 2058 | + | |
| 2059 | + s = s.Replace(assuredQuote, markerString); | |
| 2060 | + | |
| 2061 | + int quoteCount = s.CharCount(quoteChar); | |
| 2062 | + if (quoteCount > 2 && quoteCount % 2 == 0) //even number and more than two quotes, assume that quotes are important to retain. | |
| 2063 | + { | |
| 2064 | + return s.Replace(markerString, quoteString); | |
| 2065 | + } | |
| 2066 | + | |
| 2067 | + while (s.IndexOf(quoteChar) == 0) //work off front of string -- and reduce it. | |
| 2068 | + { | |
| 2069 | + if (s[s.Length - 1] == quoteChar) //have matching end quote | |
| 2070 | + { | |
| 2071 | + s = s.Substring(1, s.Length - 2); | |
| 2072 | + int nq = s.IndexOf(quoteChar); | |
| 2073 | + int ns = s.IndexOf(' '); | |
| 2074 | + if (nq > -1 && ns > -1 && nq > ns) //allow white spaces between quotes -- but don't strip spaces following quotes | |
| 2075 | + s.Trim(); | |
| 2076 | + if (s.Length <= 1) | |
| 2077 | + return s.Replace(markerString, quoteString); | |
| 2078 | + } | |
| 2079 | + else | |
| 2080 | + { | |
| 2081 | + break; | |
| 2082 | + } | |
| 2083 | + } | |
| 2084 | + return s.Replace(markerString, quoteString); | |
| 2085 | + } | |
| 2086 | + | |
| 2087 | + /// <summary> | |
| 2088 | + /// | |
| 2089 | + /// </summary> | |
| 2090 | + /// <param name="value"></param> | |
| 2091 | + /// <param name="quoteChars"></param> | |
| 2092 | + /// <returns></returns> | |
| 2093 | + public static string quoteUnwrap(this string value, char[] quoteChars) | |
| 2094 | + { | |
| 2095 | + if (string.IsNullOrEmpty(value)) | |
| 2096 | + return string.Empty; | |
| 2097 | + | |
| 2098 | + if (quoteChars == null || quoteChars[0] == 0) | |
| 2099 | + return value; | |
| 2100 | + | |
| 2101 | + foreach (char c in quoteChars) | |
| 2102 | + { | |
| 2103 | + value = value.quoteUnwrap(c); | |
| 2104 | + } | |
| 2105 | + | |
| 2106 | + return value; | |
| 2107 | + } | |
| 1669 | 2108 | } |
| 1670 | 2109 | } |