java/src/com/android/inputmethod/latin/StringUtils.java - platform/packages/inputmethods/LatinIME - Git at Google

 /*
  * Copyright (C) 2012 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */

 package com.android.inputmethod.latin;

 import android.text.TextUtils;

 import java.util.ArrayList;
 import java.util.Locale;

 public final class StringUtils {
     public static final int CAPITALIZE_NONE = 0;  // No caps, or mixed case
     public static final int CAPITALIZE_FIRST = 1; // First only
     public static final int CAPITALIZE_ALL = 2;   // All caps

     private StringUtils() {
         // This utility class is not publicly instantiable.
     }

     public static int codePointCount(final String text) {
         if (TextUtils.isEmpty(text)) return 0;
         return text.codePointCount(0, text.length());
     }

     public static boolean containsInArray(final String key, final String[] array) {
         for (final String element : array) {
             if (key.equals(element)) return true;
         }
         return false;
     }

     public static boolean containsInCsv(final String key, final String csv) {
         if (TextUtils.isEmpty(csv)) return false;
         return containsInArray(key, csv.split(","));
     }

     public static String appendToCsvIfNotExists(final String key, final String csv) {
         if (TextUtils.isEmpty(csv)) return key;
         if (containsInCsv(key, csv)) return csv;
         return csv + "," + key;
     }

     public static String removeFromCsvIfExists(final String key, final String csv) {
         if (TextUtils.isEmpty(csv)) return "";
         final String[] elements = csv.split(",");
         if (!containsInArray(key, elements)) return csv;
         final ArrayList<String> result = CollectionUtils.newArrayList(elements.length - 1);
         for (final String element : elements) {
             if (!key.equals(element)) result.add(element);
         }
         return TextUtils.join(",", result);
     }

     /**
      * Find a value that has a specified key from an array of key-comma-value.
      *
      * @param key a key string to find.
      * @param array an array of key-comma-value string to be searched.
      * @return the value part of the first string that has a specified key.
      * Returns null if it couldn't be found.
      */
     public static String findValueOfKey(final String key, final String[] array) {
         if (array == null) {
             return null;
         }
         for (final String element : array) {
             final int posComma = element.indexOf(',');
             if (posComma < 0) {
                 throw new RuntimeException("Element has no comma: " + element);
             }
             if (element.substring(0, posComma).equals(key)) {
                 return element.substring(posComma + 1);
             }
         }
         return null;
     }

     /**
      * Remove duplicates from an array of strings.
      *
      * This method will always keep the first occurrence of all strings at their position
      * in the array, removing the subsequent ones.
      */
     public static void removeDupes(final ArrayList<String> suggestions) {
         if (suggestions.size() < 2) return;
         int i = 1;
         // Don't cache suggestions.size(), since we may be removing items
         while (i < suggestions.size()) {
             final String cur = suggestions.get(i);
             // Compare each suggestion with each previous suggestion
             for (int j = 0; j < i; j++) {
                 final String previous = suggestions.get(j);
                 if (TextUtils.equals(cur, previous)) {
                     suggestions.remove(i);
                     i--;
                     break;
                 }
             }
             i++;
         }
     }

     public static String capitalizeFirstCodePoint(final String s, final Locale locale) {
         if (s.length() <= 1) {
             return s.toUpperCase(locale);
         }
         // Please refer to the comment below in
         // {@link #capitalizeFirstAndDowncaseRest(String,Locale)} as this has the same shortcomings
         final int cutoff = s.offsetByCodePoints(0, 1);
         return s.substring(0, cutoff).toUpperCase(locale) + s.substring(cutoff);
     }

     public static String capitalizeFirstAndDowncaseRest(final String s, final Locale locale) {
         if (s.length() <= 1) {
             return s.toUpperCase(locale);
         }
         // TODO: fix the bugs below
         // - This does not work for Greek, because it returns upper case instead of title case.
         // - It does not work for Serbian, because it fails to account for the "lj" character,
         // which should be "Lj" in title case and "LJ" in upper case.
         // - It does not work for Dutch, because it fails to account for the "ij" digraph when it's
         // written as two separate code points. They are two different characters but both should
         // be capitalized as "IJ" as if they were a single letter in most words (not all). If the
         // unicode char for the ligature is used however, it works.
         final int cutoff = s.offsetByCodePoints(0, 1);
         return s.substring(0, cutoff).toUpperCase(locale) + s.substring(cutoff).toLowerCase(locale);
     }

     private static final int[] EMPTY_CODEPOINTS = {};

     public static int[] toCodePointArray(final String string) {
         final int length = string.length();
         if (length <= 0) {
             return EMPTY_CODEPOINTS;
         }
         final int[] codePoints = new int[string.codePointCount(0, length)];
         int destIndex = 0;
         for (int index = 0; index < length; index = string.offsetByCodePoints(index, 1)) {
             codePoints[destIndex] = string.codePointAt(index);
             destIndex++;
         }
         return codePoints;
     }

     public static String[] parseCsvString(final String text) {
         final int size = text.length();
         if (size == 0) {
             return null;
         }
         if (codePointCount(text) == 1) {
             return text.codePointAt(0) == Constants.CSV_SEPARATOR ? null : new String[] { text };
         }

         ArrayList<String> list = null;
         int start = 0;
         for (int pos = 0; pos < size; pos++) {
             final char c = text.charAt(pos);
             if (c == Constants.CSV_SEPARATOR) {
                 // Skip empty entry.
                 if (pos - start > 0) {
                     if (list == null) {
                         list = CollectionUtils.newArrayList();
                     }
                     list.add(text.substring(start, pos));
                 }
                 // Skip comma
                 start = pos + 1;
             } else if (c == Constants.CSV_ESCAPE) {
                 // Skip escape character and escaped character.
                 pos++;
             }
         }
         final String remain = (size - start > 0) ? text.substring(start) : null;
         if (list == null) {
             return remain != null ? new String[] { remain } : null;
         }
         if (remain != null) {
             list.add(remain);
         }
         return list.toArray(new String[list.size()]);
     }

     // This method assumes the text is not null. For the empty string, it returns CAPITALIZE_NONE.
     public static int getCapitalizationType(final String text) {
         // If the first char is not uppercase, then the word is either all lower case or
         // camel case, and in either case we return CAPITALIZE_NONE.
         final int len = text.length();
         int index = 0;
         for (; index < len; index = text.offsetByCodePoints(index, 1)) {
             if (Character.isLetter(text.codePointAt(index))) {
                 break;
             }
         }
         if (index == len) return CAPITALIZE_NONE;
         if (!Character.isUpperCase(text.codePointAt(index))) {
             return CAPITALIZE_NONE;
         }
         int capsCount = 1;
         int letterCount = 1;
         for (index = text.offsetByCodePoints(index, 1); index < len;
                 index = text.offsetByCodePoints(index, 1)) {
             if (1 != capsCount && letterCount != capsCount) break;
             final int codePoint = text.codePointAt(index);
             if (Character.isUpperCase(codePoint)) {
                 ++capsCount;
                 ++letterCount;
             } else if (Character.isLetter(codePoint)) {
                 // We need to discount non-letters since they may not be upper-case, but may
                 // still be part of a word (e.g. single quote or dash, as in "IT'S" or "FULL-TIME")
                 ++letterCount;
             }
         }
         // We know the first char is upper case. So we want to test if either every letter other
         // than the first is lower case, or if they are all upper case. If the string is exactly
         // one char long, then we will arrive here with letterCount 1, and this is correct, too.
         if (1 == capsCount) return CAPITALIZE_FIRST;
         return (letterCount == capsCount ? CAPITALIZE_ALL : CAPITALIZE_NONE);
     }

     public static boolean isIdenticalAfterUpcase(final String text) {
         final int len = text.length();
         for (int i = 0; i < len; i = text.offsetByCodePoints(i, 1)) {
             final int codePoint = text.codePointAt(i);
             if (Character.isLetter(codePoint) && !Character.isUpperCase(codePoint)) {
                 return false;
             }
         }
         return true;
     }

     public static boolean isIdenticalAfterDowncase(final String text) {
         final int len = text.length();
         for (int i = 0; i < len; i = text.offsetByCodePoints(i, 1)) {
             final int codePoint = text.codePointAt(i);
             if (Character.isLetter(codePoint) && !Character.isLowerCase(codePoint)) {
                 return false;
             }
         }
         return true;
     }

     public static boolean isIdenticalAfterCapitalizeEachWord(final String text,
             final String separators) {
         boolean needCapsNext = true;
         final int len = text.length();
         for (int i = 0; i < len; i = text.offsetByCodePoints(i, 1)) {
             final int codePoint = text.codePointAt(i);
             if (Character.isLetter(codePoint)) {
                 if ((needCapsNext && !Character.isUpperCase(codePoint))
                         || (!needCapsNext && !Character.isLowerCase(codePoint))) {
                     return false;
                 }
             }
             // We need a capital letter next if this is a separator.
             needCapsNext = (-1 != separators.indexOf(codePoint));
         }
         return true;
     }

     // TODO: like capitalizeFirst*, this does not work perfectly for Dutch because of the IJ digraph
     // which should be capitalized together in *some* cases.
     public static String capitalizeEachWord(final String text, final String separators,
             final Locale locale) {
         final StringBuilder builder = new StringBuilder();
         boolean needCapsNext = true;
         final int len = text.length();
         for (int i = 0; i < len; i = text.offsetByCodePoints(i, 1)) {
             final String nextChar = text.substring(i, text.offsetByCodePoints(i, 1));
             if (needCapsNext) {
                 builder.append(nextChar.toUpperCase(locale));
             } else {
                 builder.append(nextChar.toLowerCase(locale));
             }
             // We need a capital letter next if this is a separator.
             needCapsNext = (-1 != separators.indexOf(nextChar.codePointAt(0)));
         }
         return builder.toString();
     }

     /**
      * Approximates whether the text before the cursor looks like a URL.
      *
      * This is not foolproof, but it should work well in the practice.
      * Essentially it walks backward from the cursor until it finds something that's not a letter,
      * digit, or common URL symbol like underscore. If it hasn't found a period yet, then it
      * does not look like a URL.
      * If the text:
      * - starts with www and contains a period
      * - starts with a slash preceded by either a slash, whitespace, or start-of-string
      * Then it looks like a URL and we return true. Otherwise, we return false.
      *
      * Note: this method is called quite often, and should be fast.
      *
      * TODO: This will return that "abc./def" and ".abc/def" look like URLs to keep down the
      * code complexity, but ideally it should not. It's acceptable for now.
      */
     public static boolean lastPartLooksLikeURL(final CharSequence text) {
         int i = text.length();
         if (0 == i) return false;
         int wCount = 0;
         int slashCount = 0;
         boolean hasSlash = false;
         boolean hasPeriod = false;
         int codePoint = 0;
         while (i > 0) {
             codePoint =  Character.codePointBefore(text, i);
             if (codePoint < Constants.CODE_PERIOD || codePoint > 'z') {
                 // Handwavy heuristic to see if that's a URL character. Anything between period
                 // and z. This includes all lower- and upper-case ascii letters, period,
                 // underscore, arrobase, question mark, equal sign. It excludes spaces, exclamation
                 // marks, double quotes...
                 // Anything that's not a URL-like character causes us to break from here and
                 // evaluate normally.
                 break;
             }
             if (Constants.CODE_PERIOD == codePoint) {
                 hasPeriod = true;
             }
             if (Constants.CODE_SLASH == codePoint) {
                 hasSlash = true;
                 if (2 == ++slashCount) {
                     return true;
                 }
             } else {
                 slashCount = 0;
             }
             if ('w' == codePoint) {
                 ++wCount;
             } else {
                 wCount = 0;
             }
             i = Character.offsetByCodePoints(text, i, -1);
         }
         // End of the text run.
         // If it starts with www and includes a period, then it looks like a URL.
         if (wCount >= 3 && hasPeriod) return true;
         // If it starts with a slash, and the code point before is whitespace, it looks like an URL.
         if (1 == slashCount && (0 == i || Character.isWhitespace(codePoint))) return true;
         // If it has both a period and a slash, it looks like an URL.
         if (hasPeriod && hasSlash) return true;
         // Otherwise, it doesn't look like an URL.
         return false;
     }
 }
	/*
	* Copyright (C) 2012 The Android Open Source Project
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	package com.android.inputmethod.latin;

	import android.text.TextUtils;

	import java.util.ArrayList;
	import java.util.Locale;

	public final class StringUtils {
	public static final int CAPITALIZE_NONE = 0; // No caps, or mixed case
	public static final int CAPITALIZE_FIRST = 1; // First only
	public static final int CAPITALIZE_ALL = 2; // All caps

	private StringUtils() {
	// This utility class is not publicly instantiable.
	}

	public static int codePointCount(final String text) {
	if (TextUtils.isEmpty(text)) return 0;
	return text.codePointCount(0, text.length());
	}

	public static boolean containsInArray(final String key, final String[] array) {
	for (final String element : array) {
	if (key.equals(element)) return true;
	}
	return false;
	}

	public static boolean containsInCsv(final String key, final String csv) {
	if (TextUtils.isEmpty(csv)) return false;
	return containsInArray(key, csv.split(","));
	}

	public static String appendToCsvIfNotExists(final String key, final String csv) {
	if (TextUtils.isEmpty(csv)) return key;
	if (containsInCsv(key, csv)) return csv;
	return csv + "," + key;
	}

	public static String removeFromCsvIfExists(final String key, final String csv) {
	if (TextUtils.isEmpty(csv)) return "";
	final String[] elements = csv.split(",");
	if (!containsInArray(key, elements)) return csv;
	final ArrayList<String> result = CollectionUtils.newArrayList(elements.length - 1);
	for (final String element : elements) {
	if (!key.equals(element)) result.add(element);
	}
	return TextUtils.join(",", result);
	}

	/**
	* Find a value that has a specified key from an array of key-comma-value.
	*
	* @param key a key string to find.
	* @param array an array of key-comma-value string to be searched.
	* @return the value part of the first string that has a specified key.
	* Returns null if it couldn't be found.
	*/
	public static String findValueOfKey(final String key, final String[] array) {
	if (array == null) {
	return null;
	}
	for (final String element : array) {
	final int posComma = element.indexOf(',');
	if (posComma < 0) {
	throw new RuntimeException("Element has no comma: " + element);
	}
	if (element.substring(0, posComma).equals(key)) {
	return element.substring(posComma + 1);
	}
	}
	return null;
	}

	/**
	* Remove duplicates from an array of strings.
	*
	* This method will always keep the first occurrence of all strings at their position
	* in the array, removing the subsequent ones.
	*/
	public static void removeDupes(final ArrayList<String> suggestions) {
	if (suggestions.size() < 2) return;
	int i = 1;
	// Don't cache suggestions.size(), since we may be removing items
	while (i < suggestions.size()) {
	final String cur = suggestions.get(i);
	// Compare each suggestion with each previous suggestion
	for (int j = 0; j < i; j++) {
	final String previous = suggestions.get(j);
	if (TextUtils.equals(cur, previous)) {
	suggestions.remove(i);
	i--;
	break;
	}
	}
	i++;
	}
	}

	public static String capitalizeFirstCodePoint(final String s, final Locale locale) {
	if (s.length() <= 1) {
	return s.toUpperCase(locale);
	}
	// Please refer to the comment below in
	// {@link #capitalizeFirstAndDowncaseRest(String,Locale)} as this has the same shortcomings
	final int cutoff = s.offsetByCodePoints(0, 1);
	return s.substring(0, cutoff).toUpperCase(locale) + s.substring(cutoff);
	}

	public static String capitalizeFirstAndDowncaseRest(final String s, final Locale locale) {
	if (s.length() <= 1) {
	return s.toUpperCase(locale);
	}
	// TODO: fix the bugs below
	// - This does not work for Greek, because it returns upper case instead of title case.
	// - It does not work for Serbian, because it fails to account for the "lj" character,
	// which should be "Lj" in title case and "LJ" in upper case.
	// - It does not work for Dutch, because it fails to account for the "ij" digraph when it's
	// written as two separate code points. They are two different characters but both should
	// be capitalized as "IJ" as if they were a single letter in most words (not all). If the
	// unicode char for the ligature is used however, it works.
	final int cutoff = s.offsetByCodePoints(0, 1);
	return s.substring(0, cutoff).toUpperCase(locale) + s.substring(cutoff).toLowerCase(locale);
	}

	private static final int[] EMPTY_CODEPOINTS = {};

	public static int[] toCodePointArray(final String string) {
	final int length = string.length();
	if (length <= 0) {
	return EMPTY_CODEPOINTS;
	}
	final int[] codePoints = new int[string.codePointCount(0, length)];
	int destIndex = 0;
	for (int index = 0; index < length; index = string.offsetByCodePoints(index, 1)) {
	codePoints[destIndex] = string.codePointAt(index);
	destIndex++;
	}
	return codePoints;
	}

	public static String[] parseCsvString(final String text) {
	final int size = text.length();
	if (size == 0) {
	return null;
	}
	if (codePointCount(text) == 1) {
	return text.codePointAt(0) == Constants.CSV_SEPARATOR ? null : new String[] { text };
	}

	ArrayList<String> list = null;
	int start = 0;
	for (int pos = 0; pos < size; pos++) {
	final char c = text.charAt(pos);
	if (c == Constants.CSV_SEPARATOR) {
	// Skip empty entry.
	if (pos - start > 0) {
	if (list == null) {
	list = CollectionUtils.newArrayList();
	}
	list.add(text.substring(start, pos));
	}
	// Skip comma
	start = pos + 1;
	} else if (c == Constants.CSV_ESCAPE) {
	// Skip escape character and escaped character.
	pos++;
	}
	}
	final String remain = (size - start > 0) ? text.substring(start) : null;
	if (list == null) {
	return remain != null ? new String[] { remain } : null;
	}
	if (remain != null) {
	list.add(remain);
	}
	return list.toArray(new String[list.size()]);
	}

	// This method assumes the text is not null. For the empty string, it returns CAPITALIZE_NONE.
	public static int getCapitalizationType(final String text) {
	// If the first char is not uppercase, then the word is either all lower case or
	// camel case, and in either case we return CAPITALIZE_NONE.
	final int len = text.length();
	int index = 0;
	for (; index < len; index = text.offsetByCodePoints(index, 1)) {
	if (Character.isLetter(text.codePointAt(index))) {
	break;
	}
	}
	if (index == len) return CAPITALIZE_NONE;
	if (!Character.isUpperCase(text.codePointAt(index))) {
	return CAPITALIZE_NONE;
	}
	int capsCount = 1;
	int letterCount = 1;
	for (index = text.offsetByCodePoints(index, 1); index < len;
	index = text.offsetByCodePoints(index, 1)) {
	if (1 != capsCount && letterCount != capsCount) break;
	final int codePoint = text.codePointAt(index);
	if (Character.isUpperCase(codePoint)) {
	++capsCount;
	++letterCount;
	} else if (Character.isLetter(codePoint)) {
	// We need to discount non-letters since they may not be upper-case, but may
	// still be part of a word (e.g. single quote or dash, as in "IT'S" or "FULL-TIME")
	++letterCount;
	}
	}
	// We know the first char is upper case. So we want to test if either every letter other
	// than the first is lower case, or if they are all upper case. If the string is exactly
	// one char long, then we will arrive here with letterCount 1, and this is correct, too.
	if (1 == capsCount) return CAPITALIZE_FIRST;
	return (letterCount == capsCount ? CAPITALIZE_ALL : CAPITALIZE_NONE);
	}

	public static boolean isIdenticalAfterUpcase(final String text) {
	final int len = text.length();
	for (int i = 0; i < len; i = text.offsetByCodePoints(i, 1)) {
	final int codePoint = text.codePointAt(i);
	if (Character.isLetter(codePoint) && !Character.isUpperCase(codePoint)) {
	return false;
	}
	}
	return true;
	}

	public static boolean isIdenticalAfterDowncase(final String text) {
	final int len = text.length();
	for (int i = 0; i < len; i = text.offsetByCodePoints(i, 1)) {
	final int codePoint = text.codePointAt(i);
	if (Character.isLetter(codePoint) && !Character.isLowerCase(codePoint)) {
	return false;
	}
	}
	return true;
	}

	public static boolean isIdenticalAfterCapitalizeEachWord(final String text,
	final String separators) {
	boolean needCapsNext = true;
	final int len = text.length();
	for (int i = 0; i < len; i = text.offsetByCodePoints(i, 1)) {
	final int codePoint = text.codePointAt(i);
	if (Character.isLetter(codePoint)) {
	if ((needCapsNext && !Character.isUpperCase(codePoint))
	\|\| (!needCapsNext && !Character.isLowerCase(codePoint))) {
	return false;
	}
	}
	// We need a capital letter next if this is a separator.
	needCapsNext = (-1 != separators.indexOf(codePoint));
	}
	return true;
	}

	// TODO: like capitalizeFirst*, this does not work perfectly for Dutch because of the IJ digraph
	// which should be capitalized together in some cases.
	public static String capitalizeEachWord(final String text, final String separators,
	final Locale locale) {
	final StringBuilder builder = new StringBuilder();
	boolean needCapsNext = true;
	final int len = text.length();
	for (int i = 0; i < len; i = text.offsetByCodePoints(i, 1)) {
	final String nextChar = text.substring(i, text.offsetByCodePoints(i, 1));
	if (needCapsNext) {
	builder.append(nextChar.toUpperCase(locale));
	} else {
	builder.append(nextChar.toLowerCase(locale));
	}
	// We need a capital letter next if this is a separator.
	needCapsNext = (-1 != separators.indexOf(nextChar.codePointAt(0)));
	}
	return builder.toString();
	}

	/**
	* Approximates whether the text before the cursor looks like a URL.
	*
	* This is not foolproof, but it should work well in the practice.
	* Essentially it walks backward from the cursor until it finds something that's not a letter,
	* digit, or common URL symbol like underscore. If it hasn't found a period yet, then it
	* does not look like a URL.
	* If the text:
	* - starts with www and contains a period
	* - starts with a slash preceded by either a slash, whitespace, or start-of-string
	* Then it looks like a URL and we return true. Otherwise, we return false.
	*
	* Note: this method is called quite often, and should be fast.
	*
	* TODO: This will return that "abc./def" and ".abc/def" look like URLs to keep down the
	* code complexity, but ideally it should not. It's acceptable for now.
	*/
	public static boolean lastPartLooksLikeURL(final CharSequence text) {
	int i = text.length();
	if (0 == i) return false;
	int wCount = 0;
	int slashCount = 0;
	boolean hasSlash = false;
	boolean hasPeriod = false;
	int codePoint = 0;
	while (i > 0) {
	codePoint = Character.codePointBefore(text, i);
	if (codePoint < Constants.CODE_PERIOD \|\| codePoint > 'z') {
	// Handwavy heuristic to see if that's a URL character. Anything between period
	// and z. This includes all lower- and upper-case ascii letters, period,
	// underscore, arrobase, question mark, equal sign. It excludes spaces, exclamation
	// marks, double quotes...
	// Anything that's not a URL-like character causes us to break from here and
	// evaluate normally.
	break;
	}
	if (Constants.CODE_PERIOD == codePoint) {
	hasPeriod = true;
	}
	if (Constants.CODE_SLASH == codePoint) {
	hasSlash = true;
	if (2 == ++slashCount) {
	return true;
	}
	} else {
	slashCount = 0;
	}
	if ('w' == codePoint) {
	++wCount;
	} else {
	wCount = 0;
	}
	i = Character.offsetByCodePoints(text, i, -1);
	}
	// End of the text run.
	// If it starts with www and includes a period, then it looks like a URL.
	if (wCount >= 3 && hasPeriod) return true;
	// If it starts with a slash, and the code point before is whitespace, it looks like an URL.
	if (1 == slashCount && (0 == i \|\| Character.isWhitespace(codePoint))) return true;
	// If it has both a period and a slash, it looks like an URL.
	if (hasPeriod && hasSlash) return true;
	// Otherwise, it doesn't look like an URL.
	return false;
	}
	}