var Discard io.Writer = discard{}

// discard is /dev/null for Golang.
type discard struct{}

func (discard) Write(p []byte) (int, error) {
	return len(p), nil
}

// DiscardReader discarded reader
func DiscardReader(r io.Reader) {
	Copy(Discard, r)

        }
    }

    @Override
    public Settings read(Reader input, Map<String, ?> options) throws IOException {
        Objects.requireNonNull(input, "input cannot be null");

        try (Reader in = input) {
            InputSource source = (InputSource) options.get(InputSource.class.getName());
            return new Settings(new SettingsStaxReader().read(in, isStrict(options), source));
        } catch (XMLStreamException e) {

    /**
     * Test method for
     * {@link org.codelibs.core.io.PropertiesUtil#load(java.util.Properties, java.io.Reader)}
     * .
     */
    @Test
    public void testLoadPropertiesReaderReaderNull() {
        exception.expect(NullArgumentException.class);
        exception.expectMessage(is("[ECL0008]argument[reader] is null."));
        final InputStreamReader inputStreamReader = null;

		ObjInfo:    oi,
		Reader:     r,
		cleanUpFns: cleanupFns,
	}, nil
}

// ObjReaderFn is a function type that takes a reader and returns
// GetObjectReader and an error. Request headers are passed to provide
// encryption parameters. cleanupFns allow cleanup funcs to be
// registered for calling after usage of the reader.

	accessKey, err = GenerateAccessKey(accessKeyMaxLen, rand.Reader)
	if err != nil {
		return "", "", err
	}
	secretKey, err = GenerateSecretKey(secretKeyMaxLen, rand.Reader)
	if err != nil {
		return "", "", err
	}
	return accessKey, secretKey, nil
}

// GenerateAccessKey returns a new access key generated randomly using
// the given io.Reader. If random is nil, crypto/rand.Reader is used.

     */
    Settings read(File input, Map<String, ?> options) throws IOException, SettingsParseException;

    /**
     * Reads the settings from the specified character reader. The reader will be automatically closed before the method
     * returns.
     *
     * @param input The reader to deserialize the settings from, must not be {@code null}.

     */
    PersistedToolchains read(File input, Map<String, ?> options) throws IOException, ToolchainsParseException;

    /**
     * Reads the toolchains from the specified character reader. The reader will be automatically closed before the
     * method returns.
     *
     * @param input The reader to deserialize the toolchains from, must not be {@code null}.

     */
    Metadata read(File input, Map<String, ?> options) throws IOException, MetadataParseException;

    /**
     * Reads the metadata from the specified character reader. The reader will be automatically closed before the method
     * returns.
     *
     * @param input The reader to deserialize the metadata from, must not be {@code null}.

	if isCompressed {
		wantEncryption := crypto.Requested(r.Header) || isEncrypted
		s2c, cb := newS2CompressReader(reader, actualPartSize, wantEncryption)
		idxCb = cb
		defer s2c.Close()
		reader = etag.Wrap(s2c, reader)
		length = -1
	}

	srcInfo.Reader, err = hash.NewReader(ctx, reader, length, "", "", actualPartSize)
	if err != nil {
		writeErrorResponse(ctx, w, toAPIError(ctx, err), r.URL)
		return
	}

	readerWg    sync.WaitGroup            // used to keep track of async reader.
}

// queueItem is an item in the queue.
type queueItem struct {
	input []byte             // raw input sent to the worker
	dst   chan []jstream.KVS // result of block decode
	err   error              // any error encountered will be set here
}

// Read - reads single record.
// Once Read is called the previous record should no longer be referenced.