Get all remaining chars, and set the index to the end of the input string

@return The remaining string. May not be <code>null</code> but may be
empty.
187861
@Nonnull
  public String getRest ()
  {
    final String ret = m_sInput.substring (m_nCurIndex);
    m_nCurIndex = m_nMaxIndex;
    return ret;
  }
1223284
public Charset getCharsetParameter() {
    String value = getParameter("charset");
    return value == null ? null : Charset.forName(value);
  }
817078
public String getString()
    {
        StringBuilder sb = new StringBuilder();
        for (int ii=0;ii<marked;ii++)
        {
            sb.append(charAt(ii));
        }
        return sb.toString();
    }
966193
public function remainingChars() {
        if ($this->char < $this->EOF) {
            $data = substr($this->data, $this->char);
            $this->char = $this->EOF;
            return $data;
        } else {
            return false;
        }
    }
407769
public static char lastChar(String str) {
	if (str == null || str.length() == 0) return 0;
	return str.charAt(str.length() - 1);
    }
960323
public static Charset[] getAvailableCharsets() {
        Collection collection = Charset.availableCharsets().values();
        return (Charset[]) collection.toArray(new Charset[collection.size()]);
    }
289404
public char getStopKey() {
        String value = Optional.fromNullable(getParameter(SignalParameters.STOP_KEY.symbol())).or("");
        return value.isEmpty() ? ' ' : value.charAt(0);
    }
704510
public function take(): string
    {
        if ($this->atEnd()) {
            $this->lastTaken = self::END;

            return self::END;
        }

        $char = $this->input[$this->index];

        $this->index += 1;

        $this->lastTaken = $char;

        return $char;
    }
170340
public String getString(Charset charset) throws IOException
    {
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        byte cc = get();
        while (cc != 0)
        {
            baos.write(cc);
            cc = get();
        }
        byte[] buf = baos.toByteArray();
        return new String(buf, charset);
    }
1122283
def remaining(self) -> str:
        """"""
        res = self.input[self.offset:]
        self.offset = len(self.input)
        return res
39127
public String remainder() {
        final String remainder = queue.substring(pos, queue.length());
        pos = queue.length();
        return remainder;
    }
1245973
public final CharSequence[] getSelectedEntries() {
        List<Integer> indices = indicesOf(values);
        Collections.sort(indices);

        if (!indices.isEmpty()) {
            CharSequence[] selectedEntries = new CharSequence[indices.size()];
            int currentIndex = 0;

            for (int index : indices) {
                selectedEntries[currentIndex] = getEntries()[index];
                currentIndex++;
            }

            return selectedEntries;
        }

        return null;
    }
1373130
public String getString() 
    {
        String string = super.getString();
        if ((string != null) && (string.length() > 0))
        {
            StringBuffer sb = new StringBuffer(string);
            if (sb.length() > m_iUnmaskedChars)
            {
                String strFiller = "" + FILLER;
                for (int i = 0; i < sb.length() - m_iUnmaskedChars; i++)
                {
                    sb.replace(i, i+1, strFiller);
                }
                string = sb.toString();
            }
        }
        return string;
    }
609021
public String nextString()
    {
        char[] buffer = new char[nextInt()];
        for (int i = 0; i < buffer.length; ++i)
        {
            buffer[i] = nextChar();
        }
        return new String(buffer);
    }
1279107
public Collection<String> split() {
        String s = ident;
        Set<String> result = new HashSet<>();

        while (s.length() > 0) {
            StringBuilder buf = new StringBuilder();

            char first = s.charAt(0);
            buf.append(first);
            int i = 1;

            if (s.length() > 1) {
                boolean camelWord;
                if (Character.isLowerCase(first)) {
                    camelWord = true;
                } else {
                    char next = s.charAt(i++);
                    buf.append(next);
                    camelWord = Character.isLowerCase(next);
                }

                while (i < s.length()) {
                    char c = s.charAt(i);
                    if (Character.isUpperCase(c)) {
                        if (camelWord) {
                            break;
                        }
                    } else if (!camelWord) {
                        break;
                    }
                    buf.append(c);
                    ++i;
                }

                if (!camelWord && i < s.length()) {
                    buf.deleteCharAt(buf.length() - 1);
                    --i;
                }
            }

            result.add(buf.toString().toLowerCase(Locale.US));
            s = s.substring(i);
        }

        return result;
    }
176532
public String getString() 
    {       // Usually overidden
        int maxLength = this.getMaxLength();
        String string = (String)this.getData();
        if (string == null)
            return Constants.BLANK;
        if (string.length() > maxLength)
            string = string.substring(0, maxLength);
        return string;
    }
990187
@Deprecated
    public char next()
    {
        if (pos < end - 1) {
            pos++;
            return text.charAt(pos);
        }
        else {
            pos = end;
            return DONE;
        }
    }