Returns the next character

@return  string|false
@since   0.1.0
774486
public function getNextCharacter()
	{
		$next = next($this->characters);
		
		if ($next === false && $this->chunker->hasNextChunk()) {
			$this->read($this->chunker->getNextChunk());
			$next = reset($this->characters);
		}
		
		return $next;
	}
609021
public String nextString()
    {
        char[] buffer = new char[nextInt()];
        for (int i = 0; i < buffer.length; ++i)
        {
            buffer[i] = nextChar();
        }
        return new String(buffer);
    }
1358580
public function getNext()
    {
        if ($this->currentToken !== null || strlen($this->currentInput) > 0) {
            $this->parseNextToken();

            return $this->currentToken;
        }

        return null;
    }
792767
private function get() {

		// Get next input character and advance position in file
		if ($this->inPos < $this->inLength) {
			$c = $this->in[$this->inPos];
			++$this->inPos;
		}
		else {
			return self::EOF;
		}

		// Test for non-problematic characters
		if ($c === "\n" || $c === self::EOF || ord($c) >= self::ORD_space) {
			return $c;
		}

		// else
		// Make linefeeds into newlines
		
		if ($c === "\r") {
			return "\n";
		}

		// else
		// Consider space

		return ' ';
	}
693147
@Override
    protected final char nextChar() {
        if (currentChar != 0) {
            char ch = currentChar;
            this.currentChar = 0;
            return ch;
        }
        if (this.currentBuffer != null) {
            int remain = this.currentBuffer.remaining();
            if (remain == 0 && this.currentIndex + 1 >= this.buffers.length) return 0;
        }
        byte b1 = nextByte();
        if (b1 >= 0) {// 1 byte, 7 bits: 0xxxxxxx
            return (char) b1;
        } else if ((b1 >> 5) == -2 && (b1 & 0x1e) != 0) { // 2 bytes, 11 bits: 110xxxxx 10xxxxxx
            return (char) (((b1 << 6) ^ nextByte()) ^ (((byte) 0xC0 << 6) ^ ((byte) 0x80)));
        } else if ((b1 >> 4) == -2) { // 3 bytes, 16 bits: 1110xxxx 10xxxxxx 10xxxxxx
            return (char) ((b1 << 12) ^ (nextByte() << 6) ^ (nextByte() ^ (((byte) 0xE0 << 12) ^ ((byte) 0x80 << 6) ^ ((byte) 0x80))));
        } else { // 4 bytes, 21 bits: 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
            throw new RuntimeException(new UnmappableCharacterException(4));
        }
    }
1209495
public function scanToEnd()
    {
        $scanned = substr($this->string, $this->scanOffset, strlen($this->string) - $this->scanOffset);
        $this->scanOffset = strlen($this->string);
        
        return $scanned;
    }
33348
public function next() {
        if (empty($this->_fp) or feof($this->_fp)) {
            return false;
        }
        if ($ser = fgetcsv($this->_fp)) {
            return $ser;
        } else {
            return false;
        }
    }
1333118
private boolean nextSegment() {
        assert(state == State.ITER_CHECK_FWD);
        // The input text [start..(iter index)[ passes the FCD check.
        pos = iter.getIndex();
        // Collect the characters being checked, in case they need to be normalized.
        if(s == null) {
            s = new StringBuilder();
        } else {
            s.setLength(0);
        }
        int prevCC = 0;
        for(;;) {
            // Fetch the next character and its fcd16 value.
            int c = iter.nextCodePoint();
            if(c < 0) { break; }
            int fcd16 = nfcImpl.getFCD16(c);
            int leadCC = fcd16 >> 8;
            if(leadCC == 0 && s.length() != 0) {
                // FCD boundary before this character.
                iter.previousCodePoint();
                break;
            }
            s.appendCodePoint(c);
            if(leadCC != 0 && (prevCC > leadCC || CollationFCD.isFCD16OfTibetanCompositeVowel(fcd16))) {
                // Fails FCD check. Find the next FCD boundary and normalize.
                for(;;) {
                    c = iter.nextCodePoint();
                    if(c < 0) { break; }
                    if(nfcImpl.getFCD16(c) <= 0xff) {
                        iter.previousCodePoint();
                        break;
                    }
                    s.appendCodePoint(c);
                }
                normalize(s);
                start = pos;
                limit = pos + s.length();
                state = State.IN_NORM_ITER_AT_LIMIT;
                pos = 0;
                return true;
            }
            prevCC = fcd16 & 0xff;
            if(prevCC == 0) {
                // FCD boundary after the last character.
                break;
            }
        }
        limit = pos + s.length();
        assert(pos != limit);
        iter.moveIndex(-s.length());
        state = State.ITER_IN_FCD_SEGMENT;
        return true;
    }
1246525
public function next() {
		$value = next($this->_data);
		return key($this->_data) !== null ? $value : false;
	}
980952
function next(){
		if( ! $this->length ){
			return false;
		}
		$p = $this->p + 1;
		if( !isset($this->children[$p]) ){
			$this->p = 0;
			return false;
		}
		$this->p = $p;
		return $this->children[$p];
	}
622342
private function nextCharacter()
    {
        ++$this->currentCharIndex;

        if ($this->annotationLen <= $this->currentCharIndex) {
            $this->currentChar = null;
        } else {
            $this->currentChar = $this->annotation[$this->currentCharIndex];
        }

        return $this->currentChar;
    }
700929
public function getPrevChar()
	{
		if( $this->direction == ">" )
			$this->pointer--;
		if( $this->pointer <= $this->count() &&  $this->pointer > 0 )
		{
			$this->direction = "<";
			$this->pointer--;
			$character = $this->buffer[$this->pointer];
		}
		return $character;
	}
335627
public function next($is_string = false)
    {
        $package = '';
        while (true) {
            if ($this->pointer >= $this->length) {
                return false;
            }

            $string = $this->string[$this->pointer];
            $this->pointer++;

            if ($is_string === true) {
                return ord($string);
            }

            $value = decbin(ord($string));

            if ($value >= 10000000 && $is_string === false) {
                // now fill to eight with 00
                $package .= $value;
            } else {
                // now fill to length of eight with 0
                $value = substr('00000000', 0, 8 - strlen($value) % 8) . $value;
                return $this->base128->getValue($package . $value);
            }
        }
        return $package;
    }
649060
public function nextLine()
    {
        $value = $this->getConnection()->_get_channel_packet(SSH2::CHANNEL_EXEC);

        return $value === true ? null : $value;
    }
605340
public function nextOutdent()
    {
        $oldLevel = $this->getIndentLevel();
        $expected = $this->getLevel();

        if ($expected < $oldLevel) {
            $newLevel = $this->outdent();
            if ($newLevel < $expected) {
                $this->throwException(
                    'Inconsistent indentation. '.
                    'Expecting either '.
                    $newLevel.
                    ' or '.
                    $oldLevel.
                    ' spaces/tabs.'
                );
            }

            return $newLevel;
        }

        return false;
    }
584138
public function getCharset() {
		if (!isset($this->charset)) {
			$numOfMatches = preg_match('/charset\s*=([^;]*)/', $this->getHeader('Content-Type'), $matches);
			if ($numOfMatches) {
				$this->charset = trim($matches[1]);
			} else {
				$this->charset = '';
			}
		}
		return $this->charset;
	}
258476
public function next() {


        // if this is a valid name
        if ($this->isValid()) {

            // find it on the index of colors
            $colorNames = Colors::getW3CIndex();

            // get the position of the name in the color index
            $pos = array_search($this->name,$colorNames);

            // if it was found on the array
            if ($pos !== false) {

                // if is the last item on the list
                if ($pos === (count($colorNames)-1)) {

                    // return the first item
                    return $colorNames[0];

                // it is not last
                } else {

                    // simply return the next item on the list
                    return $colorNames[$pos+1];
                }

            // name not found in list
            } else {

                // if it is not a W3C color, return null
                return null;

            }

        // invalid color
        } else {
            return null;
        }
        

        
    }