}

    @Override
    public Model read(Reader reader, boolean strict, InputSource source) throws IOException, XmlPullParserException {
        return super.read(reader, strict, source);
    }

    @Override
    public Model read(Reader reader, boolean strict) throws IOException, XmlPullParserException {
        return super.read(reader, strict);
    }

    @Override

}

func newCountUpReader(reader io.Reader) *countUpReader {
	return &countUpReader{
		reader: reader,
	}
}

type progressReader struct {
	rc              io.ReadCloser
	scannedReader   *countUpReader
	processedReader *countUpReader

	closedMu sync.Mutex
	closer   io.ReadCloser
	closed   bool
}

func (pr *progressReader) Read(p []byte) (n int, err error) {

    valueSetCapacity = DEFAULT_VALUE_SET_CAPACITY;
    int distinctKeys = stream.readInt();
    Map<K, Collection<V>> map = Platform.newLinkedHashMapWithExpectedSize(12);
    for (int i = 0; i < distinctKeys; i++) {
      @SuppressWarnings("unchecked")
      K key = (K) stream.readObject();
      map.put(key, createCollection(key));
    }
    int entries = stream.readInt();
    for (int i = 0; i < entries; i++) {

    valueSetCapacity = DEFAULT_VALUE_SET_CAPACITY;
    int distinctKeys = stream.readInt();
    Map<K, Collection<V>> map = Platform.newLinkedHashMapWithExpectedSize(12);
    for (int i = 0; i < distinctKeys; i++) {
      @SuppressWarnings("unchecked")
      K key = (K) stream.readObject();
      map.put(key, createCollection(key));
    }
    int entries = stream.readInt();
    for (int i = 0; i < entries; i++) {

    }

    /**
     * Wraps the reader with a {@link BufferedReader} if necessary.
     *
     * @param reader the reader
     * @return the wrapped reader
     */
    protected static Reader wrap(final Reader reader) {
        if (reader instanceof BufferedReader) {
            return reader;
        }
        if (reader instanceof StringReader) {
            return reader;
        }

// Return pointer to testOneByteReadNoEOF{}
func newTestReaderNoEOF(data []byte) io.Reader {
	return &testOneByteReadNoEOF{false, data}
}

// testOneByteReadNoEOF - implements io.Reader which returns 1 byte and nil error, but
// returns io.EOF on the next Read().
type testOneByteReadNoEOF struct {
	eof  bool
	data []byte
}

func (r *testOneByteReadNoEOF) Read(p []byte) (n int, err error) {
	if r.eof {
		return 0, io.EOF
	}

        this.permissions = value;
    }

    public String getReading() {
        checkSpecifiedProperty("reading");
        return convertEmptyToNull(reading);
    }

    public void setReading(String value) {
        registerModifiedProperty("reading");
        this.reading = value;
    }

    public String getSuggestWord() {
        checkSpecifiedProperty("suggestWord");

    }

    @Nonnull
    default T read(@Nonnull InputStream input, boolean strict) throws XmlReaderException {
        return read(XmlReaderRequest.builder().inputStream(input).strict(strict).build());
    }

    @Nonnull
    default T read(@Nonnull Reader reader) throws XmlReaderException {
        return read(reader, true);
    }

    @Nonnull

    }

    /**
     * Method read.
     *
     * @param reader a reader object.
     * @param strict a strict object.
     * @return Metadata
     * @throws IOException            IOException if any.
     * @throws XmlPullParserException XmlPullParserException if
     *                                any.
     */
    public Metadata read(Reader reader, boolean strict) throws IOException, XmlPullParserException {

     * Returns the contents read from the reader as a string.
     *
     * @param reader
     *            the reader
     * @param initialCapacity
     *            the initial buffer capacity
     * @return the string read from the reader
     */
    protected static String read(final Reader reader, final int initialCapacity) {
        int bufferSize;
        if (initialCapacity > 0 && initialCapacity <= MAX_BUF_SIZE) {