// HasReadAccess provides a mock function with given fields: _a0, _a1, _a2
436346
func (_m *CollectionStore) HasReadAccess(_a0 common.CollectionCriteria, _a1 *peer.SignedProposal, _a2 ledger.QueryExecutor) (bool, error) {
	ret := _m.Called(_a0, _a1, _a2)

	var r0 bool
	if rf, ok := ret.Get(0).(func(common.CollectionCriteria, *peer.SignedProposal, ledger.QueryExecutor) bool); ok {
		r0 = rf(_a0, _a1, _a2)
	} else {
		r0 = ret.Get(0).(bool)
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(common.CollectionCriteria, *peer.SignedProposal, ledger.QueryExecutor) error); ok {
		r1 = rf(_a0, _a1, _a2)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}
725437
func (db *readTraceDB) Has(key []byte) (bool, error) {
	_, err := db.Get(key)
	return err == nil, nil
}
246990
func (r *RestartTracker) GetReason() string {
	r.lock.Lock()
	defer r.lock.Unlock()
	return r.reason
}
1885
func HasAskForMore(ctx context.Context) bool {
	_, ok := ctx.Value(ctxKeyAskForMore).(bool)
	return ok
}
606131
func (f *Facade) GetReadHosts(ctx datastore.Context) ([]host.ReadHost, error) {
	defer ctx.Metrics().Stop(ctx.Metrics().Start("Facade.GetReadHosts"))
	hosts, err := f.hostStore.GetN(ctx, 20000)
	if err != nil {
		return nil, err
	}

	return toReadHosts(hosts), nil
}
927736
func (m *MockConnector) MultiRead(arg0 context.Context, arg1 *dosa.EntityInfo, arg2 []map[string]dosa.FieldValue, arg3 []string) ([]*dosa.FieldValuesOrError, error) {
	ret := m.ctrl.Call(m, "MultiRead", arg0, arg1, arg2, arg3)
	ret0, _ := ret[0].([]*dosa.FieldValuesOrError)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
252121
func (g *groupReader) hasNext() bool {
	if g.group != nil && len(g.group) > 0 {
		return true
	}
	return g.fill()
}
477435
func (r *decodingReadSeeker) getReadaheadFactor() int64 {
	mb := int64(1 << 20)
	switch {
	case r.size >= 1000*mb:
		return 16
	case r.size >= 500*mb:
		return 8
	default:
		return 4
	}
}
323551
func (c *PostgresCacher) IsExist(key string) bool {
	var data []byte
	err := c.c.QueryRow("SELECT data FROM cache WHERE key=$1", c.md5(key)).Scan(&data)
	if err != nil && err != sql.ErrNoRows {
		panic("cache/postgres: error checking existence: " + err.Error())
	}
	return err != sql.ErrNoRows
}
512487
func (md *RootMetadataV2) IsReader(
	_ context.Context, user keybase1.UID, deviceKey kbfscrypto.CryptPublicKey,
	_ TeamMembershipChecker, _ ExtraMetadata,
	_ keybase1.OfflineAvailability) (bool, error) {
	switch md.ID.Type() {
	case tlf.Public:
		return true, nil
	case tlf.Private:
		return md.RKeys.IsReader(user, deviceKey), nil
	case tlf.SingleTeam:
		// There are no read-only users of single-team TLFs.
		return false, nil
	default:
		panic(fmt.Sprintf("Unexpected TLF type: %s", md.ID.Type()))
	}
}
845102
func HasNames(args []string) (bool, error) {
	args = normalizeMultipleResourcesArgs(args)
	hasCombinedTypes, err := hasCombinedTypeArgs(args)
	if err != nil {
		return false, err
	}
	return hasCombinedTypes || len(args) > 1, nil
}
994670
func (c *ContextTemplateData) HasParamAndHeader(name string) bool {
	if c.Params == nil || c.Headers == nil {
		return false
	}

	headerAtt := c.Headers.Type.ToObject()[name]
	headerName := codegen.GoifyAtt(headerAtt, name, true)
	for paramName, paramAtt := range c.Params.Type.ToObject() {
		paramName = codegen.GoifyAtt(paramAtt, paramName, true)
		if headerName == paramName {
			return true
		}
	}
	return false
}
456603
func (m *MultiError) HasError() error {
	m.mutex.Lock()
	defer m.mutex.Unlock()
	if len(m.errs) == 0 {
		return nil
	}

	return m
}
806507
func (c *GroupsHistoryCall) Unreads(unreads bool) *GroupsHistoryCall {
	c.unreads = unreads
	return c
}
1027425
func (p *Pagination) HasNextPage() bool {
	if !p.started {
		return true
	}

	hasNextPage := len(p.nextTokens) != 0
	if p.EndPageOnSameToken {
		return hasNextPage && !awsutil.DeepEqual(p.nextTokens, p.prevTokens)
	}
	return hasNextPage
}
16442
func (d *Document) HasErrors() bool {
	return d.Errors != nil && len(d.Errors) > 0
}
1264700
func WithReadonlyPaths(paths []string) SpecOpts {
	return func(_ context.Context, _ Client, _ *containers.Container, s *Spec) error {
		setLinux(s)
		s.Linux.ReadonlyPaths = paths
		return nil
	}
}