Returns the end position of a string. Sets the error state if the column is empty.

@return the end position of the string or -1 if an error occurred
551122
protected final int nextStringEndPos(byte[] bytes, int startPos, int limit, byte[] delimiter) {
		int endPos = startPos;

		final int delimLimit = limit - delimiter.length + 1;

		while (endPos < limit) {
			if (endPos < delimLimit && delimiterNext(bytes, endPos, delimiter)) {
				break;
			}
			endPos++;
		}

		if (endPos == startPos) {
			setErrorState(ParseErrorState.EMPTY_COLUMN);
			return -1;
		}
		return endPos;
	}
836909
public int getEnd(int index) {
		if (this.endpos == null)
			throw new IllegalStateException("A result is not set.");
		if (index < 0 || this.nofgroups <= index)
			throw new IllegalArgumentException(
					"The parameter must be less than " + this.nofgroups + ": "
							+ index);
		return this.endpos[index];
	}
699908
function endsWith(target, searchString, position) {
  position = position || target.length;
  position = position - searchString.length;
  let lastIndex = target.lastIndexOf(searchString);
  return lastIndex !== -1 && lastIndex === position;
}
496254
private static int findEndOfLine(final ByteBuf buffer) {
        final int n = buffer.writerIndex();
        for (int i = buffer.readerIndex(); i < n; i++) {
            final byte b = buffer.getByte(i);
            if (b == '\r' && i < n - 1 && buffer.getByte(i + 1) == '\n') {
                return i;  // \r\n
            }
        }
        return -1;  // Not found.
    }
880116
public function getColumnOffset() {
        // strrpos is weird, and the offset needs to be negative for what we
        // want (i.e., the last \n before $this->char). This needs to not have
        // one (to make it point to the next character, the one we want the
        // position of) added to it because strrpos's behaviour includes the
        // final offset byte.
        $lastLine = strrpos($this->data, "\n", $this->char - 1 - strlen($this->data));

        // However, for here we want the length up until the next byte to be
        // processed, so add one to the current byte ($this->char).
        if ($lastLine !== false) {
            $findLengthOf = substr($this->data, $lastLine + 1, $this->char - 1 - $lastLine);
        } else {
            $findLengthOf = substr($this->data, 0, $this->char);
        }

        // Get the length for the string we need.
        if (extension_loaded('iconv')) {
            return iconv_strlen($findLengthOf, 'utf-8');
        } elseif (extension_loaded('mbstring')) {
            return mb_strlen($findLengthOf, 'utf-8');
        } elseif (extension_loaded('xml')) {
            return strlen(utf8_decode($findLengthOf));
        } else {
            $count = count_chars($findLengthOf);
            // 0x80 = 0x7F - 0 + 1 (one added to get inclusive range)
            // 0x33 = 0xF4 - 0x2C + 1 (one added to get inclusive range)
            return array_sum(array_slice($count, 0, 0x80)) +
                   array_sum(array_slice($count, 0xC2, 0x33));
        }
    }
633540
public Location remainder()
	{
		Location remainder= null;

		if( mPosition == 0 )
		{
			remainder= mBounds;
		}
		else
		{
			if( mIncrement > 0 )
			{
				remainder = mBounds.suffix( mPosition );
			}
			else
			{
				remainder = mBounds.prefix( mPosition );
			}
		}

		return remainder;

	}
1337618
public static int findLastNotOf(String container, String charSeq, int end){
        for (int i = end; i < container.length() && i >= 0; --i){
            if (!charSeq.contains("" + container.charAt(i)))
                return i;        
        }
        return -1;
    }
1101458
@Deprecated
	@Override
	public String getSequence(Long beginPosition, Long endPosition) {

		if (beginPosition == null || endPosition == null
				|| (beginPosition > endPosition) || beginPosition < 1
				|| endPosition >getLength()) {
			return null;
		}
		
       int length = (int) (endPosition.longValue() - beginPosition.longValue()) + 1;
	   int offset = beginPosition.intValue() - 1;
	   String subSequence=null;
		try{
			subSequence= ByteBufferUtils.string(getSequenceBuffer(), offset, length);
		}
		catch(Exception e)
		{
			e.printStackTrace();
			return subSequence;
		}
        return subSequence;
		/*// note begin:1 end:4 has length 4
		

		byte[] subsequence = new byte[length];

		
		synchronized (sequence) {
			sequence.position(offset);
			sequence.get(subsequence, 0, length);
		}
		
		String string = new String(subsequence);

		return string;*/
	}
118993
def range_end(self):
        '''
        '''
        count = self.count
        range_end = self.range_start + self.limit - 1
        if count < range_end:
            range_end = count
        return range_end
461415
public static boolean endWith(@Nullable CharSequence s, char c) {
		if (StringUtils.isEmpty(s)) {
			return false;
		}
		return s.charAt(s.length() - 1) == c;
	}
686797
@Override
    public String getMessage() {
        final int maxTipLength = 10;
        int end = position + 1;
        int start = end - maxTipLength;
        if (start < 0) {
            start = 0;
        }
        if (end > jsonString.length()) {
            end = jsonString.length();
        }
        return String.format("%s (%d):%s", jsonString.substring(start, end), position, super.getMessage());
    }
598806
public function columnOffset() {
        // Short circuit for the first char.
        if ($this->char == 0) {
            return 0;
        }
        // strrpos is weird, and the offset needs to be negative for what we
        // want (i.e., the last \n before $this->char). This needs to not have
        // one (to make it point to the next character, the one we want the
        // position of) added to it because strrpos's behaviour includes the
        // final offset byte.
        $backwardFrom = $this->char - 1 - strlen($this->data);
        $lastLine = strrpos($this->data, "\n", $backwardFrom);

        // However, for here we want the length up until the next byte to be
        // processed, so add one to the current byte ($this->char).
        if ($lastLine !== false) {
            $findLengthOf = substr($this->data, $lastLine + 1, $this->char - 1 - $lastLine);
        } else {
            // After a newline.
            $findLengthOf = substr($this->data, 0, $this->char);
        }

        return HTML5_Parser_UTF8Utils::countChars($findLengthOf);
    }
170844
public Position getPosition(final String pos) {
        final String s = pos.toUpperCase(Locale.US);
        final int len = s.length();
        int status = 0;

        int row = 0;
        int col = 0;
        int n = 0;
        while (n < len) {
            final char c = s.charAt(n);
            switch (status) {
                case BEGIN_LETTER: // opt $
                case BEGIN_DIGIT: // opt $
                    status++;
                    if (c == '$') n++;
                    break;
                case FIRST_LETTER: // mand letter
                    if ('A' <= c && c <= 'Z') {
                        col = c - 'A' + 1;
                        status = PositionUtil.OPT_SECOND_LETTER;
                        n++;
                    } else return null;
                    break;
                case OPT_SECOND_LETTER: // opt letter
                    if ('A' <= c && c <= 'Z') {
                        col = col * ALPHABET_SIZE + c - ORD_A + 1;
                        n++;
                    }
                    status = PositionUtil.BEGIN_DIGIT;
                    break;
                case FIRST_DIGIT: // mand digit
                    if ('0' <= c && c <= '9') {
                        row = c - '0';
                        status = PositionUtil.OPT_DIGIT;
                        n++;
                    } else return null;
                    break;
                case OPT_DIGIT: // opt digit
                    if ('0' <= c && c <= '9') {
                        row = row * 10 + c - '0';
                        n++;
                    } else return null;
                    break;
                default:
                    return null;
            }
        }
        return new Position(this.equalityUtil, this.tableNameUtil, row - 1, col - 1);
    }
105591
public StrBuilder del(int start, int end) {
		if (start < 0) {
			start = 0;
		}
		if (end > this.position) {
			end = this.position;
		}
		if (start > end) {
			throw new StringIndexOutOfBoundsException("Start is greater than End.");
		}
		if (end == this.position) {
			this.position = start;
		}

		int len = end - start;
		if (len > 0) {
			System.arraycopy(value, start + len, value, start, this.position - end);
			this.position -= len;
		}
		return this;
	}
1304962
def character_offset_end(self):
        
        if self._character_offset_end is None:
            offsets = self._element.xpath('CharacterOffsetEnd/text()')
            if len(offsets) > 0:
                self._character_offset_end = int(offsets[0])
        return self._character_offset_end
168399
private static String trimAtNull(final String s)
	{
		final int end = s.indexOf((char) 0);
		return end > -1 ? s.substring(0, end) : s;
	}
615551
function endsWith(str, prefix) {
  return (str.indexOf(prefix, str.length - prefix.length) !== -1);
}