Ends with stop.

@param str the string
@return true, if this token is ended with stop '.'
960324
public static boolean endsWithStop(String str) {
	if (str.endsWith(".") || str.endsWith("?") || str.endsWith("!")) {
	    return true;
	}
	
	return false;
    }
138381
public static boolean isLetter(String str, int beginIndex, int endIndex)
    {
        for ( int i = beginIndex; i < endIndex; i++ ) {
            char chr = str.charAt(i);
            if ( ! StringUtil.isEnLetter(chr) ) {
                return false;
            }
        }

        return true;
    }
102226
public static function stringEndsWith($str, $postfix)
    {
        if(is_array($postfix)){
            foreach($postfix as $p){
                if($p === "" || substr($str, -strlen($p)) === $p){
                    return true;
                }
            }
            return false;
        }
        return $postfix === "" || substr($str, -strlen($postfix)) === $postfix;
    }
1154183
function(str, end) {
    return (str.length >= end.length &&
            str.substring(str.length - end.length) === end);
  }
871603
def endswith_partial(text, partial_str):
    ''''''
    # at the end of the content
    # we don't care about complete overlap, so start checking
    # for matches without the last character
    test_str = partial_str[:-1]
    # look for progressively smaller segments
    while test_str:
        if text.endswith(test_str):
            return len(test_str)
        test_str = test_str[:-1]
    return False
1290779
public boolean endsWith(String str)
    {
        /* Let's just play this safe; should seldom if ever happen...
         * and because of that, can be sub-optimal, performancewise, to
         * alternatives.
         */
        if (mInputStart >= 0) {
            unshare(16);
        }

        int segIndex = (mSegments == null) ? 0 : mSegments.size();
        int inIndex = str.length() - 1;
        char[] buf = mCurrentSegment;
        int bufIndex = mCurrentSize-1;

        while (inIndex >= 0) {
            if (str.charAt(inIndex) != buf[bufIndex]) {
                return false;
            }
            if (--inIndex == 0) {
                break;
            }
            if (--bufIndex < 0) {
                if (--segIndex < 0) { // no more data?
                    return false;
                }
                buf = mSegments.get(segIndex);
                bufIndex = buf.length-1;
            }
        }

        return true;
    }
1130520
public static function match(string $str, string $start, string $end) {
		$start = preg_quote($start);
		$end = preg_quote($end);
		if (preg_match('/' . $start . '(.*)' . $end . '/', $str, $matches)) {
			return $matches[1] . '';
		}
		return false;
	}
1059671
public int end() {
    Preconditions.checkState(match != null, "Have not called find()");
    if (match.getEndLocation() >= 0) {
      return tokens.get(match.getEndLocation() - 1).end();
    }
    return -1;
  }
154691
function endsWithString(endingValue, valueToTest) {
  const position = valueToTest.length - endingValue.length;
  const lastIndexOfValue = valueToTest.lastIndexOf(endingValue);

  return !!~lastIndexOfValue && lastIndexOfValue === position;
}
935454
public static boolean isWhitespace(CharSequence str){
        if(str!=null){
            for(int i=0; i<str.length(); i++){
                if(!Character.isWhitespace(str.charAt(i)))
                    return false;
            }
        }
        return true;
    }
245224
function stringEndsWith (str, val, startIndex) {
  var rest = '' + str
  return arguments.length === 1 ? rest.indexOf(val) === rest.length - 1 : rest.substring(0, startIndex).indexOf(val) === startIndex - 1
}
1213658
protected static String removeExtension(String str, String ext) {
        if (!str.endsWith(ext)) {
            return str;
        }
        int index = str.lastIndexOf(ext);
        index = index <= 0 ? 1 : index;
        str = str.substring(0, index - 1);
        return str;
    }
944685
function (str) {
      var strlen = str.length;
      if (this.html.substr(this.currentChar, strlen).toLowerCase() === str.toLowerCase()) {
        this.currentChar += strlen;
        return true;
      }
      return false;
    }
652100
public static boolean endsWith(CharSequence s, char c) {
        int len = s.length();
        return len > 0 && s.charAt(len - 1) == c;
    }
927879
public static boolean isToken(String str) {
		// token := 1*<any (US-ASCII) CHAR except SPACE, CTLs, or tspecials>
		// tspecials := "(" / ")" / "<" / ">" / "@" / "," / ";" / ":" / "\" /
		// <"> / "/" / "[" / "]" / "?" / "="
		// CTL := 0.- 31., 127.

		final int length = str.length();
		if (length == 0)
			return false;

		for (int idx = 0; idx < length; idx++) {
			char ch = str.charAt(idx);
			if (!TOKEN_CHARS.get(ch))
				return false;
		}

		return true;
	}
984207
public static boolean startsWithAny(String _str, String... _startStrings) {
        if (_str == null || _startStrings == null || _startStrings.length == 0) {
            return false;
        }

        for (String start : _startStrings) {
            if (_str.startsWith(start)) {
                return true;
            }
        }

        return false;
    }
902719
public static boolean isEmpty(String str) {
        if (str == null)
            return true;
        if ("".equals(str.trim()))
            return true;
        return str.isEmpty();
    }