read node name, after read nodeName
@return String
@throws IOException
964530
protected AttributeList getAttributeList() throws IOException {
        int i;
        int quote;
        String name = null;
        String value = null;
        StringBuilder buffer = new StringBuilder();
        Map<String, String> attributes = new LinkedHashMap<String, String>();
        Stream stream = this.stream;

        while(true) {
            // skip invalid character
            while((i = stream.peek()) != Stream.EOF) {
                if(Character.isLetter(i) || Character.isDigit(i) || i == ':' || i == '-' || i == '_' || i == '%' || i == '/' || i == '>') {
                    break;
                }
                else {
                    stream.read();
                }
            }

            // check end
            if(i == Stream.EOF) {
                break;
            }

            if(i == '>') {
                break;
            }
            else if(i == '%' || i == '/') {
                if(stream.peek(1) == '>') {
                    break;
                }
                continue;
            }
            else {
            }

            // read name
            while((i = stream.peek()) != -1) {
                if(Character.isLetter(i) || Character.isDigit(i) || i == ':' || i == '-' || i == '_') {
                    buffer.append((char)i);
                    stream.read();
                }
                else {
                    break;
                }
            }

            name = buffer.toString();
            buffer.setLength(0);

            if(name.length() < 1) {
                continue;
            }

            this.stream.skipWhitespace();
            i = this.stream.peek();

            // next character must be '='
            if(i != '=') {
                attributes.put(name, "");
                continue;
            }
            else {
                this.stream.read();
            }

            this.stream.skipWhitespace();
            i = stream.peek();

            if(i == '"') {
                quote = '"';
                stream.read();
            }
            else if(i == '\'') {
                quote = '\'';
                stream.read();
            }
            else {
                quote = ' ';
            }

            if(quote == ' ') {
                value = this.getAttributeValue(buffer);
            }
            else {
                value = this.getAttributeValue(buffer, quote);
            }
            attributes.put(name, value);
            buffer.setLength(0);
        }
        this.stream.skipWhitespace();
        return this.getAttributeList(attributes);
    }
1195885
private void readNameToNode(CoronaSerializer coronaSerializer)
    throws IOException {
    coronaSerializer.readField("nameToNode");
    // Expecting the START_OBJECT token for nameToNode
    coronaSerializer.readStartObjectToken("nameToNode");
    JsonToken current = coronaSerializer.nextToken();
    while (current != JsonToken.END_OBJECT) {
      // nodeName is the key, and the ClusterNode is the value here
      String nodeName = coronaSerializer.getFieldName();
      ClusterNode clusterNode = new ClusterNode(coronaSerializer);
      if (!nameToNode.containsKey(nodeName)) {
        nameToNode.put(nodeName, clusterNode);
      }
      current = coronaSerializer.nextToken();
    }
    // Done with reading the END_OBJECT token for nameToNode
  }
504097
public String getName() throws IOException {
        if (name != null)
            return name;

        if (isIPv4) {
            //IPv4 address or subdomain
            byte[] host = new byte[4];
            System.arraycopy(address, 0, host, 0, 4);
            name = InetAddress.getByAddress(host).getHostAddress();
            if (address.length == 8) {
                byte[] mask = new byte[4];
                System.arraycopy(address, 4, mask, 0, 4);
                name = name + "/" +
                       InetAddress.getByAddress(mask).getHostAddress();
            }
        } else {
            //IPv6 address or subdomain
            byte[] host = new byte[16];
            System.arraycopy(address, 0, host, 0, 16);
            name = InetAddress.getByAddress(host).getHostAddress();
            if (address.length == 32) {
                // IPv6 subdomain: display prefix length

                // copy subdomain into new array and convert to BitArray
                byte[] maskBytes = new byte[16];
                for (int i=16; i < 32; i++)
                    maskBytes[i-16] = address[i];
                BitArray ba = new BitArray(16*8, maskBytes);
                // Find first zero bit
                int i=0;
                for (; i < 16*8; i++) {
                    if (!ba.get(i))
                        break;
                }
                name = name + "/" + i;
                // Verify remaining bits 0
                for (; i < 16*8; i++) {
                    if (ba.get(i)) {
                        throw new IOException("Invalid IPv6 subdomain - set " +
                            "bit " + i + " not contiguous");
                    }
                }
            }
        }
        return name;
    }
143501
protected function getName(): string
    {
        if (!isset($this->name) || !$this->name) {
            $this->name = @stream_socket_get_name($this->socket, true);
        }
        return $this->name;
    }
1105209
private final void readName(FontFileReader in) throws IOException {
        seekTab(in, "name", 2);
        int i = in.getCurrentPos();
        int n = in.readTTFUShort();
        int j = in.readTTFUShort() + i - 2;
        i += 2 * 2;

        while (n-- > 0) {
            // getLogger().debug("Iteration: " + n);
            in.seekSet(i);
            final int platformID = in.readTTFUShort();
            final int encodingID = in.readTTFUShort();
            final int languageID = in.readTTFUShort();

            int k = in.readTTFUShort();
            int l = in.readTTFUShort();

            if (((platformID == 1 || platformID == 3) 
                    && (encodingID == 0 || encodingID == 1))
                    && (k == 1 || k == 2 || k == 0 || k == 4 || k == 6)) {
                in.seekSet(j + in.readTTFUShort());
                String txt = in.readTTFString(l);
                
                log.debug(platformID + " " 
                    + encodingID + " "
                    + languageID + " "
                    + k + " " + txt);
                switch (k) {
                case 0:
                    notice = txt;
                    break;
                case 1:
                    familyName = txt;
                    break;
                case 2:
                    subFamilyName = txt;
                    break;
                case 4:
                    fullName = txt;
                    break;
                case 6:
                    fontName = txt;
                    break;
                }
                if (!notice.equals("")
                        && !fullName.equals("")
                        && !fontName.equals("")
                        && !familyName.equals("")
                        && !subFamilyName.equals("")) {
                    break;
                }
            }
            i += 6 * 2;
        }
    }
293644
private function readExternName()
    {
        $length = self::getInt2d($this->data, $this->pos + 2);
        $recordData = $this->readRecordData($this->data, $this->pos + 4, $length);

        // move stream pointer to next record
        $this->pos += 4 + $length;

        // external sheet references provided for named cells
        if ($this->version == self::XLS_BIFF8) {
            // offset: 0; size: 2; options
            $options = self::getInt2d($recordData, 0);

            // offset: 2; size: 2;

            // offset: 4; size: 2; not used

            // offset: 6; size: var
            $nameString = self::readUnicodeStringShort(substr($recordData, 6));

            // offset: var; size: var; formula data
            $offset = 6 + $nameString['size'];
            $formula = $this->getFormulaFromStructure(substr($recordData, $offset));

            $this->externalNames[] = array(
                'name' => $nameString['value'],
                'formula' => $formula,
            );
        }
    }
83821
public function getNode()
    {
        $node = hexdec(bin2hex(random_bytes(6)));

        // Set the multicast bit; see RFC 4122, section 4.5.
        $node = $node | 0x010000000000;

        return str_pad(dechex($node), 12, '0', STR_PAD_LEFT);
    }
1154397
private static String getNodeName(Node n) {
        String nodeName = n.getLocalName();
        if (nodeName == null || nodeName.length() == 0) {
            nodeName = n.getNodeName();
        }
        return nodeName;
    }
618497
public function getDisplayName()
    {
        if ($this->name !== '') {
            $result = $this->name;
        } else {
            $result = '';
            $string = trim($this->handle, '_-');
            $segments = preg_split('/[_-]+/', $string);
            foreach ($segments as $segment) {
                if ($segment !== '') {
                    $len = mb_strlen($segment);
                    if ($len === 1) {
                        $segment = mb_strtoupper($segment);
                    } else {
                        $segment = mb_strtoupper(mb_substr($segment, 0, 1)) . mb_substr($segment, 1);
                    }
                    if ($result === '') {
                        $result = $segment;
                    } else {
                        $result .= ' ' . $segment;
                    }
                }
            }
            if ($result === '') {
                $result = $this->handle;
            }
        }

        return $result;
    }
317561
public String readString()
        throws IOException
    {
        int tag = read();

        switch (tag) {
            case 'N':
                return null;

            case 'I':
                return String.valueOf(parseInt());
            case 'L':
                return String.valueOf(parseLong());
            case 'D':
                return String.valueOf(parseDouble());

            case 'S':
            case 's':
            case 'X':
            case 'x':
                _isLastChunk = tag == 'S' || tag == 'X';
                _chunkLength = (read() << 8) + read();

                _sbuf.setLength(0);
                int ch;

                while ((ch = parseChar()) >= 0)
                    _sbuf.append((char) ch);

                return _sbuf.toString();

            default:
                throw expect("string", tag);
        }
    }
379880
public function readBinaryObject()
    {
        // first: read the marker byte
        if (strlen($buff = substr($this->content, $this->pos, 1)) != 1) {
            throw IOException::readError("");
        }
        $this->pos++;

        $object_length = unpack("C*", $buff);
        $object_length = $object_length[1]  & 0xF;
        $buff = unpack("H*", $buff);
        $buff = $buff[1];

        $object_type = substr($buff, 0, 1);
        if ($object_type != "0" && $object_length == 15) {
            $object_length = $this->readBinaryObject();
            $object_length = $object_length->getValue();
        }

        $retval = null;
        switch ($object_type) {
            case '0': // null, false, true, fillbyte
                $retval = $this->readBinaryNullType($object_length);
                break;
            case '1': // integer
                $retval = $this->readBinaryInt($object_length);
                break;
            case '2': // real
                $retval = $this->readBinaryReal($object_length);
                break;
            case '3': // date
                $retval = $this->readBinaryDate($object_length);
                break;
            case '4': // data
                $retval = $this->readBinaryData($object_length);
                break;
            case '5': // byte string, usually utf8 encoded
                $retval = $this->readBinaryString($object_length);
                break;
            case '6': // unicode string (utf16be)
                $retval = $this->readBinaryUnicodeString($object_length);
                break;
            case '8':
                $num = $this->readBinaryInt($object_length);
                $retval = new CFUid($num->getValue());
                break;
            case 'a': // array
                $retval = $this->readBinaryArray($object_length);
                break;
            case 'd': // dictionary
                $retval = $this->readBinaryDict($object_length);
                break;
        }

        return $retval;
    }
574686
public String read() throws IOException {
        StringWriter out = new StringWriter();
        PrintWriter w = new PrintWriter(out);
        try (BufferedReader in = Files.newBufferedReader(Util.fileToPath(file), StandardCharsets.UTF_8)) {
            String line;
            while ((line = in.readLine()) != null)
                w.println(line);
        } catch (Exception e) {
            throw new IOException("Failed to fully read " + file, e);
        }
        return out.toString();
    }
675018
private function read()
    {
        $s = null;

        for (; !feof($this->sock);) {
            if (($line = fgets($this->sock, 1e3)) == null) {
                continue;
            }

            $s = explode(' ', $line)[0];

            if (preg_match('#^[0-9]+$#', $s)) {
                break;
            }
        }

        return (int) $s;
    }
1058797
public function getNode()
    {
        if(null === $this->node)
        {
            $request = $this->requestStack->getCurrentRequest();
            $this->node = $this->readNode(RequestFilter::getFinder($request, $this->contentPath));
        }

        return $this->node;
    }
945036
public int read() throws KNXMLException
	{
		while (canRead()) {
			// init line counter on first read
			if (line == 0)
				line = 1;

			read('<');
			String str = read('>');
			// if no comment and no closing tag
			if (str.length() == 0 || skipComment(str) || skipInstruction(str))
				continue;
			final StringBuffer buf = new StringBuffer();
			if (readCDATASection(str, buf)) {
				elem = new DefaultElement((String) openElems.peek());
				elem.setCharacterData(buf.toString());
				pos = CHAR_DATA;
				return pos;
			}
			str = str.trim();
			// extract element name
			final String name = splitOnSpace(str);
			if (name.charAt(0) == '/') {
				if (!name.substring(1).equals(openElems.peek()))
					throw new KNXMLException("element end tag does not match start tag",
						name.substring(1), line);
				elem = new DefaultElement((String) openElems.pop());
				pos = END_TAG;
				return pos;
			}
			elem = new DefaultElement(name);
			extractAttributes(str.substring(name.length()));
			if (!elem.isEmptyElementTag())
				openElems.push(name);
			pos = START_TAG;
			return pos;
		}
		if (!openElems.empty())
			throw new KNXMLException("end of XML input with elements left open");
		pos = END_DOC;
		return pos;
	}
1061855
public org.w3c.dom.Node readNode()
        throws IOException
    {
        int tag = read();

        switch (tag) {
            case 'N':
                return null;

            case 'S':
            case 's':
            case 'X':
            case 'x':
                _isLastChunk = tag == 'S' || tag == 'X';
                _chunkLength = (read() << 8) + read();

                throw error("Can't handle string in this context");

            default:
                throw expect("string", tag);
        }
    }
1014564
public int read() throws IOException {
        int c = super.read();
        if( c == -1 && filenames.hasNext() ) {
            cueStream();
            return read();
        }
        return c;
    }