Gecko [ www.smanegeri1koba.sch.id ]

Name	Size	Permission
h2c	[ DIR ]	dr-xr-xr-x
h2i	[ DIR ]	dr-xr-xr-x
hpack	[ DIR ]	dr-xr-xr-x
testdata	[ DIR ]	dr-xr-xr-x
.gitignore	11 B	-r--r--r--
ascii.go	1.35 KB	-r--r--r--
ascii_test.go	1.77 KB	-r--r--r--
ciphers.go	34.38 KB	-r--r--r--
ciphers_test.go	12.77 KB	-r--r--r--
client_conn_pool.go	8.4 KB	-r--r--r--
databuffer.go	4.26 KB	-r--r--r--
databuffer_test.go	4.28 KB	-r--r--r--
errors.go	4.52 KB	-r--r--r--
errors_test.go	533 B	-r--r--r--
flow.go	3.29 KB	-r--r--r--
flow_test.go	3.25 KB	-r--r--r--
frame.go	46.95 KB	-r--r--r--
frame_test.go	30.73 KB	-r--r--r--
gotrack.go	3.09 KB	-r--r--r--
gotrack_test.go	761 B	-r--r--r--
headermap.go	2.15 KB	-r--r--r--
http2.go	9.54 KB	-r--r--r--
http2_test.go	6.47 KB	-r--r--r--
pipe.go	4.08 KB	-r--r--r--
pipe_test.go	3 KB	-r--r--r--
server.go	101.31 KB	-r--r--r--
server_push_test.go	15.71 KB	-r--r--r--
server_test.go	128.81 KB	-r--r--r--
transport.go	89.77 KB	-r--r--r--
transport_test.go	166.92 KB	-r--r--r--
write.go	10.67 KB	-r--r--r--
writesched.go	7.66 KB	-r--r--r--
writesched_priority.go	13.34 KB	-r--r--r--
writesched_priority_test.go	17.86 KB	-r--r--r--
writesched_random.go	2 KB	-r--r--r--
writesched_random_test.go	1.76 KB	-r--r--r--
writesched_roundrobin.go	2.75 KB	-r--r--r--
writesched_roundrobin_test.go	1.59 KB	-r--r--r--
writesched_test.go	5.18 KB	-r--r--r--
z_spec_test.go	7.27 KB	-r--r--r--

Code Editor : pipe.go

// Copyright 2014 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.

package http2

import (
	"errors"
	"io"
	"sync"
)

// pipe is a goroutine-safe io.Reader/io.Writer pair. It's like
// io.Pipe except there are no PipeReader/PipeWriter halves, and the
// underlying buffer is an interface. (io.Pipe is always unbuffered)
type pipe struct {
	mu       sync.Mutex
	c        sync.Cond     // c.L lazily initialized to &p.mu
	b        pipeBuffer    // nil when done reading
	unread   int           // bytes unread when done
	err      error         // read error once empty. non-nil means closed.
	breakErr error         // immediate read error (caller doesn't see rest of b)
	donec    chan struct{} // closed on error
	readFn   func()        // optional code to run in Read before error
}

type pipeBuffer interface {
	Len() int
	io.Writer
	io.Reader
}

// setBuffer initializes the pipe buffer.
// It has no effect if the pipe is already closed.
func (p *pipe) setBuffer(b pipeBuffer) {
	p.mu.Lock()
	defer p.mu.Unlock()
	if p.err != nil || p.breakErr != nil {
		return
	}
	p.b = b
}

func (p *pipe) Len() int {
	p.mu.Lock()
	defer p.mu.Unlock()
	if p.b == nil {
		return p.unread
	}
	return p.b.Len()
}

// Read waits until data is available and copies bytes
// from the buffer into p.
func (p *pipe) Read(d []byte) (n int, err error) {
	p.mu.Lock()
	defer p.mu.Unlock()
	if p.c.L == nil {
		p.c.L = &p.mu
	}
	for {
		if p.breakErr != nil {
			return 0, p.breakErr
		}
		if p.b != nil && p.b.Len() > 0 {
			return p.b.Read(d)
		}
		if p.err != nil {
			if p.readFn != nil {
				p.readFn()     // e.g. copy trailers
				p.readFn = nil // not sticky like p.err
			}
			p.b = nil
			return 0, p.err
		}
		p.c.Wait()
	}
}

var errClosedPipeWrite = errors.New("write on closed buffer")

// Write copies bytes from p into the buffer and wakes a reader.
// It is an error to write more data than the buffer can hold.
func (p *pipe) Write(d []byte) (n int, err error) {
	p.mu.Lock()
	defer p.mu.Unlock()
	if p.c.L == nil {
		p.c.L = &p.mu
	}
	defer p.c.Signal()
	if p.err != nil || p.breakErr != nil {
		return 0, errClosedPipeWrite
	}
	return p.b.Write(d)
}

// CloseWithError causes the next Read (waking up a current blocked
// Read if needed) to return the provided err after all data has been
// read.
//
// The error must be non-nil.
func (p *pipe) CloseWithError(err error) { p.closeWithError(&p.err, err, nil) }

// BreakWithError causes the next Read (waking up a current blocked
// Read if needed) to return the provided err immediately, without
// waiting for unread data.
func (p *pipe) BreakWithError(err error) { p.closeWithError(&p.breakErr, err, nil) }

// closeWithErrorAndCode is like CloseWithError but also sets some code to run
// in the caller's goroutine before returning the error.
func (p *pipe) closeWithErrorAndCode(err error, fn func()) { p.closeWithError(&p.err, err, fn) }

func (p *pipe) closeWithError(dst *error, err error, fn func()) {
	if err == nil {
		panic("err must be non-nil")
	}
	p.mu.Lock()
	defer p.mu.Unlock()
	if p.c.L == nil {
		p.c.L = &p.mu
	}
	defer p.c.Signal()
	if *dst != nil {
		// Already been done.
		return
	}
	p.readFn = fn
	if dst == &p.breakErr {
		if p.b != nil {
			p.unread += p.b.Len()
		}
		p.b = nil
	}
	*dst = err
	p.closeDoneLocked()
}

// requires p.mu be held.
func (p *pipe) closeDoneLocked() {
	if p.donec == nil {
		return
	}
	// Close if unclosed. This isn't racy since we always
	// hold p.mu while closing.
	select {
	case <-p.donec:
	default:
		close(p.donec)
	}
}

// Err returns the error (if any) first set by BreakWithError or CloseWithError.
func (p *pipe) Err() error {
	p.mu.Lock()
	defer p.mu.Unlock()
	if p.breakErr != nil {
		return p.breakErr
	}
	return p.err
}

// Done returns a channel which is closed if and when this pipe is closed
// with CloseWithError.
func (p *pipe) Done() <-chan struct{} {
	p.mu.Lock()
	defer p.mu.Unlock()
	if p.donec == nil {
		p.donec = make(chan struct{})
		if p.err != nil || p.breakErr != nil {
			// Already hit an error.
			p.closeDoneLocked()
		}
	}
	return p.donec
}

${this.title}

Code Editor : pipe.go