// get return an item or nil if not found.
966480
func (db *DB) get(key string) *dbItem {
	item := db.keys.Get(&dbItem{key: key})
	if item != nil {
		return item.(*dbItem)
	}
	return nil
}
563119
func (k *ArrayKeyring) Get(key string) (Item, error) {
	if i, ok := k.items[key]; ok {
		return i, nil
	}
	return Item{}, ErrKeyNotFound
}
463865
func Get() (Interface, error) {
	v, err := value.Get()
	if err != nil {
		return nil, err
	}
	return v.(Interface), nil
}
1303434
func (c *SyncCollector) Get(k string) interface{} {
	var v interface{}
	c.rw.RLock()
	v = c.c.Get(k)
	c.rw.RUnlock()
	return v
}
1062970
func (c *Client) Get() *Request {
	req := c.Request()
	req.Method("GET")
	return req
}
1373837
func (b *DynamoDBBackend) Get(ctx context.Context, key []byte) (*backend.Item, error) {
	r, err := b.getKey(ctx, key)
	if err != nil {
		return nil, err
	}
	item := &backend.Item{
		Key:   trimPrefix(r.FullPath),
		Value: r.Value,
		ID:    r.ID,
	}
	if r.Expires != nil {
		item.Expires = time.Unix(*r.Expires, 0)
	}
	return item, nil
}
451462
func (s *GenericStorage) Get(key interface{}) (interface{}, error) {
	if s.get == nil && s.getMulti == nil {
		return nil, errors.Newf(
			"'%s' does not have Get/GetMulti implementation",
			s.name)
	}

	s.rwMutex.RLock()
	defer s.rwMutex.RUnlock()

	if s.get != nil {
		return s.get(key)
	}

	items, err := s.getMulti(key)
	if err != nil {
		return nil, err
	}
	return items[0], nil
}
1277884
func (c *APIContext) Get(key string) (value interface{}, exists bool) {
	if c.keys != nil {
		value, exists = c.keys[key]
	}
	return
}
238363
func (f *Value) Get() (interface{}, error) {
	// Try outside of a lock
	if ok, value, err := f.get(); ok {
		return value, err
	}

	f.RLock()
	defer f.RUnlock()

	_, value, err := f.get()
	return value, err
}
783146
func (_m *Client) Get(uid string, options groveclient.GetOptions) (*groveclient.PostItem, error) {
	ret := _m.Called(uid, options)

	var r0 *groveclient.PostItem
	if rf, ok := ret.Get(0).(func(string, groveclient.GetOptions) *groveclient.PostItem); ok {
		r0 = rf(uid, options)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*groveclient.PostItem)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(string, groveclient.GetOptions) error); ok {
		r1 = rf(uid, options)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}
1097685
func (obj *object) Get(k *Term) *Term {
	if elem := obj.get(k); elem != nil {
		return elem.value
	}
	return nil
}
359394
func (c *FileCacher) Get(key string) interface{} {
	item, err := c.read(key)
	if err != nil {
		return nil
	}

	if item.hasExpired() {
		os.Remove(c.filepath(key))
		return nil
	}
	return item.Val
}
672794
func (f *Request) Get(url string) *Request {
	f.Url(url).Method("GET")
	return f
}
206604
func (e *Error) Get() error {
	e.lock.RLock()
	defer e.lock.RUnlock()

	return e.err
}
769239
func (m *Memory) Get(ctx context.Context, key []byte) (*backend.Item, error) {
	if len(key) == 0 {
		return nil, trace.BadParameter("missing parameter key")
	}
	m.Lock()
	defer m.Unlock()
	m.removeExpired()
	i := m.tree.Get(&btreeItem{Item: backend.Item{Key: key}})
	if i == nil {
		return nil, trace.NotFound("key %q is not found", string(key))
	}
	item := i.(*btreeItem).Item
	return &item, nil
}
1233362
func (F *Frisby) Get(url string) *Frisby {
	F.Method = "GET"
	F.Url = url
	return F
}
710863
func (c *unfurlCache) get(key string) (res cacheItem, ok bool) {
	c.Lock()
	defer c.Unlock()

	item, ok := c.cache.Get(key)
	if !ok {
		return res, false
	}
	cacheItem, ok := item.(cacheItem)
	if !ok {
		return res, false
	}
	valid := c.clock.Now().Sub(cacheItem.ctime.Time()) <= defaultCacheLifetime
	if !valid {
		c.cache.Remove(key)
	}
	return cacheItem, valid
}