// Copyright 2012 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Copied from Go distribution src/go/build/read.go.

package imports

import (
	"bufio"
	"bytes"
	"errors"
	"io"
	"unicode/utf8"
)

type importReader struct {
	b    *bufio.Reader
	buf  []byte
	peek byte
	err  error
	eof  bool
	nerr int
}

	}

	if val.Type().Kind() == reflect.Slice && val.Type().Elem().Kind() != reflect.Uint8 {
		// Slice of element values.
		// Grow slice.
		n := val.Len()
		val.Grow(1)
		val.SetLen(n + 1)

		// Recur to read element into slice.
		if err := d.unmarshalAttr(val.Index(n), attr); err != nil {
			val.SetLen(n)
			return err
		}
		return nil
	}

	if val.Type() == attrType {
		val.Set(reflect.ValueOf(attr))

}

func error_PivotRoot(newroot string, oldroot string) (err error) {
	err = ENOSYS
	return
}

// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT

func Pread(fd int, p []byte, offset int64) (n int, err error) {
	var _p0 unsafe.Pointer
	if len(p) > 0 {
		_p0 = unsafe.Pointer(&p[0])
	} else {
		_p0 = unsafe.Pointer(&_zero)
	}
	runtime.EnterSyscall()

                assert new String(buffer, 0, nread) == "some "

                nread = stream.read(buffer)
                assert nread == 4
                assert new String(buffer, 0, nread) == "text"

                nread = stream.read(buffer)
                assert nread == -1
            }
            thread.blockUntil.requested
            stream.received(bytes)
            stream.close()
        }

	if errno := m.munmap(uintptr(unsafe.Pointer(&b[0])), uintptr(len(b))); errno != nil {
		return errno
	}
	delete(m.active, p)
	return nil
}

func Read(fd int, p []byte) (n int, err error) {
	n, err = read(fd, p)
	if raceenabled {
		if n > 0 {
			raceWriteRange(unsafe.Pointer(&p[0]), n)
		}
		if err == nil {
			raceAcquire(unsafe.Pointer(&ioSync))
		}
	}
	return

            if (writePos > readPos) {
                int nread = Math.min(count, writePos - readPos);
                System.arraycopy(buffer, readPos, bytes, pos, nread);
                readPos += nread;
                assert writePos >= readPos;
                condition.signalAll();
                return nread;
            }

            assert inputFinished;
            return -1;

        assertReads(instr, "end")

        def nread = instr.read(new byte[20])
        assertThat(nread, equalTo(-1))

        instr.close()
    }

    @Test
    void canReadSingleChars() {
        def instr = new DisconnectableInputStream(stream("abc"), toActionExecuter(executorFactory))

        assertThat((char) instr.read(), equalTo('a'.charAt(0)))
        assertThat((char) instr.read(), equalTo('b'.charAt(0)))

            hasher.putHash(SIGNATURE);
            while (true) {
                int nread = inputStream.read(buffer);
                if (nread < 0) {
                    break;
                }
                outputStream.write(buffer, 0, nread);
                hasher.putBytes(buffer, 0, nread);
            }
            return hasher.hash();
        } finally {
            returnBuffer(buffer);

            while (!closed) {
                int nread = inputStream.read(buffer);
                if (nread < 0) {
                    break;
                }
                BuildOperationRef startupRef = this.associatedBuildOperation;
                if (startupRef != null) {
                    CurrentBuildOperationRef.instance().with(startupRef, () -> {
                        writeBuffer(buffer, nread);
                        return null;

		// - Add. An unschedulable Pod may fail due to violating topology spread constraints,
		// adding an assigned Pod may make it schedulable.
		// - Update. Updating on an existing Pod's labels (e.g., removal) may make
		// an unschedulable Pod schedulable.
		// - Delete. An unschedulable Pod may fail due to violating an existing Pod's topology spread constraints,
		// deleting an existing Pod may make it schedulable.