// MultiRead not implemented
978656
func (c *Connector) MultiRead(ctx context.Context, ei *dosa.EntityInfo, keys []map[string]dosa.FieldValue, minimumFields []string) (results []*dosa.FieldValuesOrError, err error) {
	return nil, new(ErrNotImplemented)
}
189714
func (sm *BaseMiddleware) PreRead(conn IOSession) (bool, interface{}, error) {
	return true, nil, nil
}
785255
func (b *ByteBuffer) UnreadRune() error {
	b.Lock()
	defer b.Unlock()
	return b.b.UnreadRune()
}
292056
func (s *RPCServer) GetThread(arg GetThreadIn, out *GetThreadOut) error {
	t, err := s.debugger.FindThread(arg.Id)
	if err != nil {
		return err
	}
	if t == nil {
		return fmt.Errorf("no thread with id %d", arg.Id)
	}
	out.Thread = t
	return nil
}
1335785
func (m *RWMutex) Report() {
	writers := atomic.LoadInt64(&m.writers)
	str := fmt.Sprintf(
		"writers %d (pending %d) readers %d",
		writers,
		atomic.LoadInt64(&m.pendingWriters),
		atomic.LoadInt64(&m.readers),
	)
	if writers > 0 {
		m.stateMutex.RLock()
		str += fmt.Sprintf(", stack: %s", string(m.lastLockStack))
		m.stateMutex.RUnlock()
	}
	m.println(str)
}
1098154
func (c *ChannelsHistoryCall) Unreads(unreads bool) *ChannelsHistoryCall {
	c.unreads = unreads
	return c
}
693358
func (n *Notification) GetUnread() bool {
	if n == nil || n.Unread == nil {
		return false
	}
	return *n.Unread
}
879437
func parseThreadSample(b *bytes.Buffer) (nextl string, addrs []uint64, err error) {
	var l string
	sameAsPrevious := false
	for {
		if l, err = b.ReadString('\n'); err != nil {
			if err != io.EOF {
				return "", nil, err
			}
			if l == "" {
				break
			}
		}
		if l = strings.TrimSpace(l); l == "" {
			continue
		}

		if strings.HasPrefix(l, "---") {
			break
		}
		if strings.Contains(l, "same as previous thread") {
			sameAsPrevious = true
			continue
		}

		addrs = append(addrs, parseHexAddresses(l)...)
	}

	if sameAsPrevious {
		return l, nil, nil
	}
	return l, addrs, nil
}
229614
func (f *Adaptor) DigitalRead(pin string) (val int, err error) {
	p, err := strconv.Atoi(pin)
	if err != nil {
		return
	}

	if f.Board.Pins()[p].Mode != client.Input {
		if err = f.Board.SetPinMode(p, client.Input); err != nil {
			return
		}
		if err = f.Board.ReportDigital(p, 1); err != nil {
			return
		}
		<-time.After(10 * time.Millisecond)
	}

	return f.Board.Pins()[p].Value, nil
}
24997
func MultiGet(kvreader KVReader, keys [][]byte) ([][]byte, error) {
	vals := make([][]byte, 0, len(keys))

	for i, key := range keys {
		val, err := kvreader.Get(key)
		if err != nil {
			return nil, err
		}

		vals[i] = val
	}

	return vals, nil
}
1067469
func (p *Process) FindThread(threadID int) (proc.Thread, bool) {
	thread, ok := p.threads[threadID]
	return thread, ok
}
239039
func (rw *BoundedRWLock) processQueue() {

	if rw.readers != 0 {
		panic("readers??")
	}

	if rw.nextWriter != nil {
		if rw.nextWriter.WakeAtomic() {
			return
		}
		rw.nextWriter = nil
	}

	for {
		var next *rwwait
		select {
		case next = <-rw.waiters:
		default:
			return
		}
		if next.writer {
			// No readers scheduled yet?
			if rw.readers == 0 {
				// If they wake up, no one else gets to go
				if next.WakeAtomic() {
					rw.nextWriter = next
					return
				}
			} else {
				rw.nextWriter = next
				return
			}
		} else {
			// Reader?  Let them enter now.
			if next.WakeAtomic() {
				rw.readers++
			}
		}
	}
}
99479
func (p *Process) FindThread(threadID int) (proc.Thread, bool) {
	t, ok := p.Threads[threadID]
	return t, ok
}
16378
func (c *Client) MultipleBatch(operations []BatchOperationIndexed, opts ...interface{}) (res MultipleBatchRes, err error) {
	body := map[string][]BatchOperationIndexed{"requests": operations}
	path := c.path("/indexes/*/batch")
	err = c.transport.Request(&res, http.MethodPost, path, body, call.Write, opts...)
	res.wait = c.waitTask
	return
}
735832
func (itr *bufIterator) Unread() {
	if itr.buf.full {
		panic("pilosa.BufIterator: buffer full")
	}
	itr.buf.full = true
}
93236
func (zip GobMeddler) PreRead(fieldAddr interface{}) (scanTarget interface{}, err error) {
	// give a pointer to a byte buffer to grab the raw data
	return new([]byte), nil
}
629283
func (p *binParser) unread() {
	if p.last > 0 {
		p.n--
		p.r.UnreadByte()
	}
}