// SetReadDeadline calls SetReadDeadline() of the underlying connection
345788
func (con *Connection) SetReadDeadline(t time.Time) error {
	return con.connection.SetReadDeadline(t)
}
616482
func (c *I2PConn) SetReadDeadline(t time.Time) error {
	return c.c.SetReadDeadline(t)
}
802478
func (br *BlockReader) SetDeadline(t time.Time) error {
	br.deadline = t
	if br.conn != nil {
		return br.conn.SetDeadline(t)
	}

	// Return the error at connection time.
	return nil
}
321354
func (c *DeadlineConn) setReadTimeout() {
	if c.readTimeout != 0 {
		c.SetReadDeadline(time.Now().UTC().Add(c.readTimeout))
	}
}
1243004
func (c *wsConn) SetReadDeadline(t time.Time) error {
	return c.conn.SetReadDeadline(t)
}
909029
func (db *DB) SetReadOnly() error {
	if err := db.ok(); err != nil {
		return err
	}

	// Lock writer.
	select {
	case db.writeLockC <- struct{}{}:
		db.compWriteLocking = true
	case err := <-db.compPerErrC:
		return err
	case <-db.closeC:
		return ErrClosed
	}

	// Set compaction read-only.
	select {
	case db.compErrSetC <- ErrReadOnly:
	case perr := <-db.compPerErrC:
		return perr
	case <-db.closeC:
		return ErrClosed
	}

	return nil
}
1320657
func (mr *MockConnMockRecorder) SetReadDeadline(t interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetReadDeadline", reflect.TypeOf((*MockConn)(nil).SetReadDeadline), t)
}
323118
func (l *Listener) SetReadBuffer(bytes int) error {
	if nc, ok := l.conn.(setReadBuffer); ok {
		return nc.SetReadBuffer(bytes)
	}
	return errors.New(errInvalidOperation)
}
694875
func (s *NetworkConnectionAction) SetConnectionDirection(v string) *NetworkConnectionAction {
	s.ConnectionDirection = &v
	return s
}
1244014
func (c *throttledConn) SetDeadline(t time.Time) error {
	return c.originalConn.SetDeadline(t)
}
346042
func (s *UpdateSMBFileShareInput) SetReadOnly(v bool) *UpdateSMBFileShareInput {
	s.ReadOnly = &v
	return s
}
144283
func (s *Stream) SetDeadline(t time.Time) error {
	if err := s.SetReadDeadline(t); err != nil {
		return err
	}
	if err := s.SetWriteDeadline(t); err != nil {
		return err
	}
	return nil
}
165254
func (d *deadlineTimer) SetReadDeadline(t time.Time) error {
	d.mu.Lock()
	d.setDeadline(&d.readCancelCh, &d.readTimer, t)
	d.mu.Unlock()
	return nil
}
364210
func SetReadHandler(r chi.Router, ops *ReadOperations) {
	handler := func(w http.ResponseWriter, r *http.Request) {
		id := chi.URLParam(r, "id")
		if reader, err := ops.Input.NewReader(id); err != nil {
			http.Error(w, http.StatusText(404), 404)
		} else {
			defer reader.Close()
			p := pipe.New(reader)
			if err := ops.SetPipe(p); err != nil {
				http.Error(w, http.StatusText(500), 500)
			}
			p.To(w)
			if err := p.Exec(); err != nil {
				http.Error(w, http.StatusText(500), 500)
			}
		}
	}

	r.Get("/{id}", handler)
}
586018
func (c *conn) readLine() ([]byte, error) {
	// To avoid allocations, attempt to read the line using ReadSlice. This
	// call typically succeeds. The known case where the call fails is when
	// reading the output from the MONITOR command.
	p, err := c.br.ReadSlice('\n')
	if err == bufio.ErrBufferFull {
		// The line does not fit in the bufio.Reader's buffer. Fall back to
		// allocating a buffer for the line.
		buf := append([]byte{}, p...)
		for err == bufio.ErrBufferFull {
			p, err = c.br.ReadSlice('\n')
			buf = append(buf, p...)
		}
		p = buf
	}
	if err != nil {
		return nil, err
	}
	i := len(p) - 2
	if i < 0 || p[i] != '\r' {
		return nil, protocolError("bad response line terminator")
	}
	return p[:i], nil
}
156571
func (s *CreateSMBFileShareInput) SetReadOnly(v bool) *CreateSMBFileShareInput {
	s.ReadOnly = &v
	return s
}
436002
func (c *Conn) SetDeadline(t time.Time) error {
	return c.opError(opSet, c.fd.SetDeadline(t, deadline))
}