5483

pending completion

Build # 5483

Build Type

push

travis-ci

Committed by

dkayiwa

Commit Message

<a href="https://github.com/openmrs/openmrs-core/commit/<a class=hub.com/openmrs/openmrs-core/commit/2ccfb23b95a475bb83fc316633c8b78c86e3ed08">2ccfb23b9<a href="https://github.com/openmrs/openmrs-core/commit/2ccfb23b95a475bb83fc316633c8b78c86e3ed08">&quot;&gt;Adding the upgrade instructions link to the error message - TRUNK-5171
(cherry picked from commit </a><a class="double-link" href="https://github.com/openmrs/openmrs-core/commit/<a class="double-link" href="https://github.com/openmrs/openmrs-core/commit/c2943cfa2769062f063e9c9582f90cb3c2748841">c2943cfa2</a>">c2943cfa2</a><a href="https://github.com/openmrs/openmrs-core/commit/2ccfb23b95a475bb83fc316633c8b78c86e3ed08">)

Run Details

2 of 2 new or added lines in 1 file covered. (100.0%)

18156 of 32512 relevant lines covered (55.84%)

0.56 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

50.42

/api/src/main/java/org/openmrs/util/NaturalStrings.java

/*
 * Copyright (c) 2006, Stephen Kelvin Friedrich,  All rights reserved.
 *
 * This a BSD license. If you use or enhance the code, I'd be pleased if you sent a mail to s.friedrich@eekboom.com
 *
 * Redistribution and use in source and binary forms, with or without modification, are permitted provided that the
 * following conditions are met:
 *     * Redistributions of source code must retain the above copyright notice, this list of conditions and the
 *       following disclaimer.
 *     * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the
         following disclaimer in the documentation and/or other materials provided with the distribution.
 *     * Neither the name of the "Stephen Kelvin Friedrich" nor the names of its contributors may be used to endorse
 *       or promote products derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
 * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

package org.openmrs.util;

import java.text.Collator;
import java.util.Comparator;

/**
 * Utility class for natural String comparison operations
 * 
 * @since 1.5
 */
public final class NaturalStrings {
        
        /**
         * <p>
         * A string comparator that does case-sensitive comparisons and handles embedded numbers
         * correctly.
         * </p>
         * <p>
         * <b>Do not use</b> if your app might ever run on any locale that uses more than 7-bit ascii
         * characters.
         * </p>
         */
        private static final Comparator<String> NATURAL_COMPARATOR_ASCII = new Comparator<String>() {
                
                public int compare(String o1, String o2) {
                        return compareNaturalAscii(o1, o2);
                }
        };
        
        /**
         * <p>
         * A string comparator that does case insensitive comparisons and handles embedded numbers
         * correctly.
         * </p>
         * <p>
         * <b>Do not use</b> if your app might ever run on any locale that uses more than 7-bit ascii
         * characters.
         * </p>
         */
        private static final Comparator<String> IGNORE_CASE_NATURAL_COMPARATOR_ASCII = new Comparator<String>() {
                
                public int compare(String o1, String o2) {
                        return compareNaturalIgnoreCaseAscii(o1, o2);
                }
        };
        
        /**
         * This is a utility class (static methods only), don't instantiate.
         */
        private NaturalStrings() {
        }
        
        /**
         * Returns a comparator that compares contained numbers based on their numeric values and
         * compares other parts using the current locale's order rules.
         * <p>
         * For example in German locale this will be a comparator that handles umlauts correctly and
         * ignores upper/lower case differences.
         * </p>
         * 
         * @return <p>
         *         A string comparator that uses the current locale's order rules and handles embedded
         *         numbers correctly.
         *         </p>
         * @see #getNaturalComparator(java.text.Collator)
         */
        public static Comparator<String> getNaturalComparator() {
                Collator collator = Collator.getInstance();
                return getNaturalComparator(collator);
        }
        
        /**
         * Returns a comparator that compares contained numbers based on their numeric values and
         * compares other parts using the given collator.
         * 
         * @param collator used for locale specific comparison of text (non-number) subwords - must not
         *            be null
         * @return <p>
         *         A string comparator that uses the given Collator to compare subwords and handles
         *         embedded numbers correctly.
         *         </p>
         * @see #getNaturalComparator()
         */
        public static Comparator<String> getNaturalComparator(final Collator collator) {
                if (collator == null) {
                        // it's important to explicitly handle this here - else the bug will manifest anytime later in possibly
                        // unrelated code that tries to use the comparator
                        throw new NullPointerException("collator must not be null");
                }
                return new Comparator<String>() {
                        
                        public int compare(String o1, String o2) {
                                return compareNatural(collator, o1, o2);
                        }
                };
        }
        
        /**
         * Returns a comparator that compares contained numbers based on their numeric values and
         * compares other parts based on each character's Unicode value.
         * 
         * @return <p>
         *         a string comparator that does case-sensitive comparisons on pure ascii strings and
         *         handles embedded numbers correctly.
         *         </p>
         *         <b>Do not use</b> if your app might ever run on any locale that uses more than 7-bit
         *         ascii characters.
         * @see #getNaturalComparator()
         * @see #getNaturalComparator(java.text.Collator)
         */
        public static Comparator<String> getNaturalComparatorAscii() {
                return NATURAL_COMPARATOR_ASCII;
        }
        
        /**
         * Returns a comparator that compares contained numbers based on their numeric values and
         * compares other parts based on each character's Unicode value while ignore upper/lower case
         * differences. <b>Do not use</b> if your app might ever run on any locale that uses more than
         * 7-bit ascii characters.
         * 
         * @return <p>
         *         a string comparator that does case insensitive comparisons on pure ascii strings and
         *         handles embedded numbers correctly.
         *         </p>
         * @see #getNaturalComparator()
         * @see #getNaturalComparator(java.text.Collator)
         */
        public static Comparator<String> getNaturalComparatorIgnoreCaseAscii() {
                return IGNORE_CASE_NATURAL_COMPARATOR_ASCII;
        }
        
        /**
         * <p>
         * Compares two strings using the current locale's rules and comparing contained numbers based
         * on their numeric values.
         * </p>
         * <p>
         * This is probably the best default comparison to use.
         * </p>
         * <p>
         * If you know that the texts to be compared are in a certain language that differs from the
         * default locale's language, then get a collator for the desired locale (
         * {@link java.text.Collator#getInstance(java.util.Locale)}) and pass it to
         * {@link #compareNatural(java.text.Collator, String, String)}
         * </p>
         * 
         * @param s first string
         * @param t second string
         * @return zero iff <code>s</code> and <code>t</code> are equal, a value less than zero iff
         *         <code>s</code> lexicographically precedes <code>t</code> and a value larger than zero
         *         iff <code>s</code> lexicographically follows <code>t</code>
         */
        public static int compareNatural(String s, String t) {
                return compareNatural(s, t, false, Collator.getInstance());
        }
        
        /**
         * <p>
         * Compares two strings using the given collator and comparing contained numbers based on their
         * numeric values.
         * </p>
         * 
         * @param s first string
         * @param t second string
         * @return zero iff <code>s</code> and <code>t</code> are equal, a value less than zero iff
         *         <code>s</code> lexicographically precedes <code>t</code> and a value larger than zero
         *         iff <code>s</code> lexicographically follows <code>t</code>
         */
        public static int compareNatural(Collator collator, String s, String t) {
                return compareNatural(s, t, true, collator);
        }
        
        /**
         * <p>
         * Compares two strings using each character's Unicode value for non-digit characters and the
         * numeric values off any contained numbers.
         * </p>
         * <p>
         * (This will probably make sense only for strings containing 7-bit ascii characters only.)
         * </p>
         * 
         * @return zero iff <code>s</code> and <code>t</code> are equal, a value less than zero iff
         *         <code>s</code> lexicographically precedes <code>t</code> and a value larger than zero
         *         iff <code>s</code> lexicographically follows <code>t</code>
         */
        public static int compareNaturalAscii(String s, String t) {
                return compareNatural(s, t, true, null);
        }
        
        /**
         * <p>
         * Compares two strings using each character's Unicode value - ignoring upper/lower case - for
         * non-digit characters and the numeric values of any contained numbers.
         * </p>
         * <p>
         * (This will probably make sense only for strings containing 7-bit ascii characters only.)
         * </p>
         * 
         * @return zero iff <code>s</code> and <code>t</code> are equal, a value less than zero iff
         *         <code>s</code> lexicographically precedes <code>t</code> and a value larger than zero
         *         iff <code>s</code> lexicographically follows <code>t</code>
         */
        public static int compareNaturalIgnoreCaseAscii(String s, String t) {
                return compareNatural(s, t, false, null);
        }
        
        /**
         * @param s first string
         * @param t second string
         * @param caseSensitive treat characters differing in case only as equal - will be ignored if a
         *            collator is given
         * @param collator used to compare subwords that aren't numbers - if null, characters will be
         *            compared individually based on their Unicode value
         * @return zero iff <code>s</code> and <code>t</code> are equal, a value less than zero iff
         *         <code>s</code> lexicographically precedes <code>t</code> and a value larger than zero
         *         iff <code>s</code> lexicographically follows <code>t</code>
         */
        private static int compareNatural(String s, String t, boolean caseSensitive, Collator collator) {
                int sIndex = 0;
                int tIndex = 0;
                
                int sLength = s.length();
                int tLength = t.length();
                
                while (true) {
                        // both character indices are after a subword (or at zero)
                        
                        // Check if one string is at end
                        if (sIndex == sLength && tIndex == tLength) {
                                return 0;
                        }
                        if (sIndex == sLength) {
                                return -1;
                        }
                        if (tIndex == tLength) {
                                return 1;
                        }
                        
                        // Compare sub word
                        char sChar = s.charAt(sIndex);
                        char tChar = t.charAt(tIndex);
                        
                        boolean sCharIsDigit = Character.isDigit(sChar);
                        boolean tCharIsDigit = Character.isDigit(tChar);
                        
                        if (sCharIsDigit && tCharIsDigit) {
                                // Compare numbers
                                
                                // skip leading 0s
                                int sLeadingZeroCount = 0;
                                while (sChar == '0') {
                                        ++sLeadingZeroCount;
                                        ++sIndex;
                                        if (sIndex == sLength) {
                                                break;
                                        }
                                        sChar = s.charAt(sIndex);
                                }
                                int tLeadingZeroCount = 0;
                                while (tChar == '0') {
                                        ++tLeadingZeroCount;
                                        ++tIndex;
                                        if (tIndex == tLength) {
                                                break;
                                        }
                                        tChar = t.charAt(tIndex);
                                }
                                boolean sAllZero = sIndex == sLength || !Character.isDigit(sChar);
                                boolean tAllZero = tIndex == tLength || !Character.isDigit(tChar);
                                if (sAllZero && tAllZero) {
                                        continue;
                                }
                                if (sAllZero && !tAllZero) {
                                        return -1;
                                }
                                if (tAllZero) {
                                        return 1;
                                }
                                
                                int diff = 0;
                                do {
                                        if (diff == 0) {
                                                diff = sChar - tChar;
                                        }
                                        ++sIndex;
                                        ++tIndex;
                                        if (sIndex == sLength && tIndex == tLength) {
                                                return diff != 0 ? diff : sLeadingZeroCount - tLeadingZeroCount;
                                        }
                                        if (sIndex == sLength) {
                                                if (diff == 0) {
                                                        return -1;
                                                }
                                                return Character.isDigit(t.charAt(tIndex)) ? -1 : diff;
                                        }
                                        if (tIndex == tLength) {
                                                if (diff == 0) {
                                                        return 1;
                                                }
                                                return Character.isDigit(s.charAt(sIndex)) ? 1 : diff;
                                        }
                                        sChar = s.charAt(sIndex);
                                        tChar = t.charAt(tIndex);
                                        sCharIsDigit = Character.isDigit(sChar);
                                        tCharIsDigit = Character.isDigit(tChar);
                                        if (!sCharIsDigit && !tCharIsDigit) {
                                                // both number sub words have the same length
                                                if (diff != 0) {
                                                        return diff;
                                                }
                                                break;
                                        }
                                        if (!sCharIsDigit) {
                                                return -1;
                                        }
                                        if (!tCharIsDigit) {
                                                return 1;
                                        }
                                } while (true);
                        } else {
                                // Compare words
                                if (collator != null) {
                                        // To use the collator the whole subwords have to be compared - character-by-character comparison
                                        // is not possible. So find the two subwords first
                                        int aw = sIndex;
                                        int bw = tIndex;
                                        do {
                                                ++sIndex;
                                        } while (sIndex < sLength && !Character.isDigit(s.charAt(sIndex)));
                                        do {
                                                ++tIndex;
                                        } while (tIndex < tLength && !Character.isDigit(t.charAt(tIndex)));
                                        
                                        String as = s.substring(aw, sIndex);
                                        String bs = t.substring(bw, tIndex);
                                        int subwordResult = collator.compare(as, bs);
                                        if (subwordResult != 0) {
                                                return subwordResult;
                                        }
                                } else {
                                        // No collator specified. All characters should be ascii only. Compare character-by-character.
                                        do {
                                                if (sChar != tChar) {
                                                        if (caseSensitive) {
                                                                return sChar - tChar;
                                                        }
                                                        sChar = Character.toUpperCase(sChar);
                                                        tChar = Character.toUpperCase(tChar);
                                                        if (sChar != tChar) {
                                                                sChar = Character.toLowerCase(sChar);
                                                                tChar = Character.toLowerCase(tChar);
                                                                if (sChar != tChar) {
                                                                        return sChar - tChar;
                                                                }
                                                        }
                                                }
                                                ++sIndex;
                                                ++tIndex;
                                                if (sIndex == sLength && tIndex == tLength) {
                                                        return 0;
                                                }
                                                if (sIndex == sLength) {
                                                        return -1;
                                                }
                                                if (tIndex == tLength) {
                                                        return 1;
                                                }
                                                sChar = s.charAt(sIndex);
                                                tChar = t.charAt(tIndex);
                                                sCharIsDigit = Character.isDigit(sChar);
                                                tCharIsDigit = Character.isDigit(tChar);
                                        } while (!sCharIsDigit && !tCharIsDigit);
                                }
                        }
                }
        }
}

1	/*
2	* Copyright (c) 2006, Stephen Kelvin Friedrich, All rights reserved.
3	*
4	* This a BSD license. If you use or enhance the code, I'd be pleased if you sent a mail to s.friedrich@eekboom.com
5	*
6	* Redistribution and use in source and binary forms, with or without modification, are permitted provided that the
7	* following conditions are met:
8	* * Redistributions of source code must retain the above copyright notice, this list of conditions and the
9	* following disclaimer.
10	* * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the
11	following disclaimer in the documentation and/or other materials provided with the distribution.
12	* * Neither the name of the "Stephen Kelvin Friedrich" nor the names of its contributors may be used to endorse
13	* or promote products derived from this software without specific prior written permission.
14	*
15	* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
16	* INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
17	* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
18	* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
19	* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
20	* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
21	* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
22	*/
23
24	package org.openmrs.util;
25
26	import java.text.Collator;
27	import java.util.Comparator;
28
29	/**
30	* Utility class for natural String comparison operations
31	*
32	* @since 1.5
33	*/
34	public final class NaturalStrings {
35
36	/**
37	* <p>
38	* A string comparator that does case-sensitive comparisons and handles embedded numbers
39	* correctly.
40	* </p>
41	* <p>
42	* <b>Do not use</b> if your app might ever run on any locale that uses more than 7-bit ascii
43	* characters.
44	* </p>
45	*/
46	private static final Comparator<String> NATURAL_COMPARATOR_ASCII = new Comparator<String>() {	1✔
47
48	public int compare(String o1, String o2) {
49	return compareNaturalAscii(o1, o2);	×
50	}
51	};
52
53	/**
54	* <p>
55	* A string comparator that does case insensitive comparisons and handles embedded numbers
56	* correctly.
57	* </p>
58	* <p>
59	* <b>Do not use</b> if your app might ever run on any locale that uses more than 7-bit ascii
60	* characters.
61	* </p>
62	*/
63	private static final Comparator<String> IGNORE_CASE_NATURAL_COMPARATOR_ASCII = new Comparator<String>() {	1✔
64
65	public int compare(String o1, String o2) {
66	return compareNaturalIgnoreCaseAscii(o1, o2);	×
67	}
68	};
69
70	/**
71	* This is a utility class (static methods only), don't instantiate.
72	*/
73	private NaturalStrings() {	×
74	}	×
75
76	/**
77	* Returns a comparator that compares contained numbers based on their numeric values and
78	* compares other parts using the current locale's order rules.
79	* <p>
80	* For example in German locale this will be a comparator that handles umlauts correctly and
81	* ignores upper/lower case differences.
82	* </p>
83	*
84	* @return <p>
85	* A string comparator that uses the current locale's order rules and handles embedded
86	* numbers correctly.
87	* </p>
88	* @see #getNaturalComparator(java.text.Collator)
89	*/
90	public static Comparator<String> getNaturalComparator() {
91	Collator collator = Collator.getInstance();	1✔
92	return getNaturalComparator(collator);	1✔
93	}
94
95	/**
96	* Returns a comparator that compares contained numbers based on their numeric values and
97	* compares other parts using the given collator.
98	*
99	* @param collator used for locale specific comparison of text (non-number) subwords - must not
100	* be null
101	* @return <p>
102	* A string comparator that uses the given Collator to compare subwords and handles
103	* embedded numbers correctly.
104	* </p>
105	* @see #getNaturalComparator()
106	*/
107	public static Comparator<String> getNaturalComparator(final Collator collator) {
108	if (collator == null) {	1✔
109	// it's important to explicitly handle this here - else the bug will manifest anytime later in possibly
110	// unrelated code that tries to use the comparator
111	throw new NullPointerException("collator must not be null");	×
112	}
113	return new Comparator<String>() {	1✔
114
115	public int compare(String o1, String o2) {
116	return compareNatural(collator, o1, o2);	1✔
117	}
118	};
119	}
120
121	/**
122	* Returns a comparator that compares contained numbers based on their numeric values and
123	* compares other parts based on each character's Unicode value.
124	*
125	* @return <p>
126	* a string comparator that does case-sensitive comparisons on pure ascii strings and
127	* handles embedded numbers correctly.
128	* </p>
129	* <b>Do not use</b> if your app might ever run on any locale that uses more than 7-bit
130	* ascii characters.
131	* @see #getNaturalComparator()
132	* @see #getNaturalComparator(java.text.Collator)
133	*/
134	public static Comparator<String> getNaturalComparatorAscii() {
135	return NATURAL_COMPARATOR_ASCII;	×
136	}
137
138	/**
139	* Returns a comparator that compares contained numbers based on their numeric values and
140	* compares other parts based on each character's Unicode value while ignore upper/lower case
141	* differences. <b>Do not use</b> if your app might ever run on any locale that uses more than
142	* 7-bit ascii characters.
143	*
144	* @return <p>
145	* a string comparator that does case insensitive comparisons on pure ascii strings and
146	* handles embedded numbers correctly.
147	* </p>
148	* @see #getNaturalComparator()
149	* @see #getNaturalComparator(java.text.Collator)
150	*/
151	public static Comparator<String> getNaturalComparatorIgnoreCaseAscii() {
152	return IGNORE_CASE_NATURAL_COMPARATOR_ASCII;	×
153	}
154
155	/**
156	* <p>
157	* Compares two strings using the current locale's rules and comparing contained numbers based
158	* on their numeric values.
159	* </p>
160	* <p>
161	* This is probably the best default comparison to use.
162	* </p>
163	* <p>
164	* If you know that the texts to be compared are in a certain language that differs from the
165	* default locale's language, then get a collator for the desired locale (
166	* {@link java.text.Collator#getInstance(java.util.Locale)}) and pass it to
167	* {@link #compareNatural(java.text.Collator, String, String)}
168	* </p>
169	*
170	* @param s first string
171	* @param t second string
172	* @return zero iff <code>s</code> and <code>t</code> are equal, a value less than zero iff
173	* <code>s</code> lexicographically precedes <code>t</code> and a value larger than zero
174	* iff <code>s</code> lexicographically follows <code>t</code>
175	*/
176	public static int compareNatural(String s, String t) {
177	return compareNatural(s, t, false, Collator.getInstance());	×
178	}
179
180	/**
181	* <p>
182	* Compares two strings using the given collator and comparing contained numbers based on their
183	* numeric values.
184	* </p>
185	*
186	* @param s first string
187	* @param t second string
188	* @return zero iff <code>s</code> and <code>t</code> are equal, a value less than zero iff
189	* <code>s</code> lexicographically precedes <code>t</code> and a value larger than zero
190	* iff <code>s</code> lexicographically follows <code>t</code>
191	*/
192	public static int compareNatural(Collator collator, String s, String t) {
193	return compareNatural(s, t, true, collator);	1✔
194	}
195
196	/**
197	* <p>
198	* Compares two strings using each character's Unicode value for non-digit characters and the
199	* numeric values off any contained numbers.
200	* </p>
201	* <p>
202	* (This will probably make sense only for strings containing 7-bit ascii characters only.)
203	* </p>
204	*
205	* @return zero iff <code>s</code> and <code>t</code> are equal, a value less than zero iff
206	* <code>s</code> lexicographically precedes <code>t</code> and a value larger than zero
207	* iff <code>s</code> lexicographically follows <code>t</code>
208	*/
209	public static int compareNaturalAscii(String s, String t) {
210	return compareNatural(s, t, true, null);	×
211	}
212
213	/**
214	* <p>
215	* Compares two strings using each character's Unicode value - ignoring upper/lower case - for
216	* non-digit characters and the numeric values of any contained numbers.
217	* </p>
218	* <p>
219	* (This will probably make sense only for strings containing 7-bit ascii characters only.)
220	* </p>
221	*
222	* @return zero iff <code>s</code> and <code>t</code> are equal, a value less than zero iff
223	* <code>s</code> lexicographically precedes <code>t</code> and a value larger than zero
224	* iff <code>s</code> lexicographically follows <code>t</code>
225	*/
226	public static int compareNaturalIgnoreCaseAscii(String s, String t) {
227	return compareNatural(s, t, false, null);	×
228	}
229
230	/**
231	* @param s first string
232	* @param t second string
233	* @param caseSensitive treat characters differing in case only as equal - will be ignored if a
234	* collator is given
235	* @param collator used to compare subwords that aren't numbers - if null, characters will be
236	* compared individually based on their Unicode value
237	* @return zero iff <code>s</code> and <code>t</code> are equal, a value less than zero iff
238	* <code>s</code> lexicographically precedes <code>t</code> and a value larger than zero
239	* iff <code>s</code> lexicographically follows <code>t</code>
240	*/
241	private static int compareNatural(String s, String t, boolean caseSensitive, Collator collator) {
242	int sIndex = 0;	1✔
243	int tIndex = 0;	1✔
244
245	int sLength = s.length();	1✔
246	int tLength = t.length();	1✔
247
248	while (true) {
249	// both character indices are after a subword (or at zero)
250
251	// Check if one string is at end
252	if (sIndex == sLength && tIndex == tLength) {	1✔
253	return 0;	×
254	}
255	if (sIndex == sLength) {	1✔
256	return -1;	×
257	}
258	if (tIndex == tLength) {	1✔
259	return 1;	×
260	}
261
262	// Compare sub word
263	char sChar = s.charAt(sIndex);	1✔
264	char tChar = t.charAt(tIndex);	1✔
265
266	boolean sCharIsDigit = Character.isDigit(sChar);	1✔
267	boolean tCharIsDigit = Character.isDigit(tChar);	1✔
268
269	if (sCharIsDigit && tCharIsDigit) {	1✔
270	// Compare numbers
271
272	// skip leading 0s
273	int sLeadingZeroCount = 0;	1✔
274	while (sChar == '0') {	1✔
275	++sLeadingZeroCount;	×
276	++sIndex;	×
277	if (sIndex == sLength) {	×
278	break;	×
279	}
280	sChar = s.charAt(sIndex);	×
281	}
282	int tLeadingZeroCount = 0;	1✔
283	while (tChar == '0') {	1✔
284	++tLeadingZeroCount;	×
285	++tIndex;	×
286	if (tIndex == tLength) {	×
287	break;	×
288	}
289	tChar = t.charAt(tIndex);	×
290	}
291	boolean sAllZero = sIndex == sLength \|\| !Character.isDigit(sChar);	1✔
292	boolean tAllZero = tIndex == tLength \|\| !Character.isDigit(tChar);	1✔
293	if (sAllZero && tAllZero) {	1✔
294	continue;	×
295	}
296	if (sAllZero && !tAllZero) {	1✔
297	return -1;	×
298	}
299	if (tAllZero) {	1✔
300	return 1;	×
301	}
302
303	int diff = 0;	1✔
304	do {
305	if (diff == 0) {	1✔
306	diff = sChar - tChar;	1✔
307	}
308	++sIndex;	1✔
309	++tIndex;	1✔
310	if (sIndex == sLength && tIndex == tLength) {	1✔
311	return diff != 0 ? diff : sLeadingZeroCount - tLeadingZeroCount;	1✔
312	}
313	if (sIndex == sLength) {	1✔
314	if (diff == 0) {	1✔
315	return -1;	×
316	}
317	return Character.isDigit(t.charAt(tIndex)) ? -1 : diff;	1✔
318	}
319	if (tIndex == tLength) {	1✔
320	if (diff == 0) {	×
321	return 1;	×
322	}
323	return Character.isDigit(s.charAt(sIndex)) ? 1 : diff;	×
324	}
325	sChar = s.charAt(sIndex);	1✔
326	tChar = t.charAt(tIndex);	1✔
327	sCharIsDigit = Character.isDigit(sChar);	1✔
328	tCharIsDigit = Character.isDigit(tChar);	1✔
329	if (!sCharIsDigit && !tCharIsDigit) {	1✔
330	// both number sub words have the same length
331	if (diff != 0) {	×
332	return diff;	×
333	}
334	break;
335	}
336	if (!sCharIsDigit) {	1✔
337	return -1;	×
338	}
339	if (!tCharIsDigit) {	1✔
340	return 1;	×
341	}
342	} while (true);
343	} else {	×
344	// Compare words
345	if (collator != null) {	1✔
346	// To use the collator the whole subwords have to be compared - character-by-character comparison
347	// is not possible. So find the two subwords first
348	int aw = sIndex;	1✔
349	int bw = tIndex;	1✔
350	do {
351	++sIndex;	1✔
352	} while (sIndex < sLength && !Character.isDigit(s.charAt(sIndex)));	1✔
353	do {
354	++tIndex;	1✔
355	} while (tIndex < tLength && !Character.isDigit(t.charAt(tIndex)));	1✔
356
357	String as = s.substring(aw, sIndex);	1✔
358	String bs = t.substring(bw, tIndex);	1✔
359	int subwordResult = collator.compare(as, bs);	1✔
360	if (subwordResult != 0) {	1✔
361	return subwordResult;	×
362	}
363	} else {	1✔
364	// No collator specified. All characters should be ascii only. Compare character-by-character.
365	do {
366	if (sChar != tChar) {	×
367	if (caseSensitive) {	×
368	return sChar - tChar;	×
369	}
370	sChar = Character.toUpperCase(sChar);	×
371	tChar = Character.toUpperCase(tChar);	×
372	if (sChar != tChar) {	×
373	sChar = Character.toLowerCase(sChar);	×
374	tChar = Character.toLowerCase(tChar);	×
375	if (sChar != tChar) {	×
376	return sChar - tChar;	×
377	}
378	}
379	}
380	++sIndex;	×
381	++tIndex;	×
382	if (sIndex == sLength && tIndex == tLength) {	×
383	return 0;	×
384	}
385	if (sIndex == sLength) {	×
386	return -1;	×
387	}
388	if (tIndex == tLength) {	×
389	return 1;	×
390	}
391	sChar = s.charAt(sIndex);	×
392	tChar = t.charAt(tIndex);	×
393	sCharIsDigit = Character.isDigit(sChar);	×
394	tCharIsDigit = Character.isDigit(tChar);	×
395	} while (!sCharIsDigit && !tCharIsDigit);	×
396	}
397	}
398	}	1✔
399	}
400	}

openmrs / openmrs-core / 5483

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous