// Get returns the timer with the given id or nil.
174517
func (t *SessionTimers) Get(id string) *time.Timer {
	t.RLock()
	defer t.RUnlock()
	return t.m[id]
}
401972
func (r *GroupService) Get(appId string, id string) *GroupGetCall {
	c := &GroupGetCall{s: r.s, urlParams_: make(gensupport.URLParams)}
	c.appId = appId
	c.id = id
	return c
}
1181442
func (m *Map) Get(k ident.ID) (MapValue, bool) {
	hash := m.hash(k)
	for entry, ok := m.lookup[hash]; ok; entry, ok = m.lookup[hash] {
		if m.equals(entry.key.key, k) {
			return entry.value, true
		}
		// Linear probe to "next" to this entry (really a rehash)
		hash++
	}
	var empty MapValue
	return empty, false
}
334832
func (d *Dispatch) Get(name string, params ...interface{}) (result *VARIANT, err error) {
	id, err := d.GetId(name)
	if err != nil {
		return
	}
	result, err = d.Invoke(id, DISPATCH_PROPERTYGET, params)
	return
}
652068
func Get(id string, params *stripe.EventParams) (*stripe.Event, error) {
	return getC().Get(id, params)
}
431972
func (r *AppService) Get(id string) *AppGetCall {
	c := &AppGetCall{s: r.s, urlParams_: make(gensupport.URLParams)}
	c.id = id
	return c
}
175060
func (i Int) Get() (int, error) {
	if !i.Present() {
		var zero int
		return zero, errors.New("value not present")
	}
	return *i.value, nil
}
1170921
func (self *Model) Get(id interface{}, into interface{}) error {
	if record, err := self.db.Retrieve(self.collection.Name, id); err == nil {
		return record.Populate(into, self.collection)
	} else {
		return err
	}
}
1054024
func (a DurationA) Get(vals ...interface{}) (val time.Duration) {
	v := get(a(0).arg(), vals)
	switch v := v.(type) {
	case *time.Duration:
		return *v
	case time.Duration:
		return v
	}
	return
}
1278301
func (h *applyHandler) Get(key string, args ...interface{}) (interface{}, error) {
	var err error
	if h.keyFunc != nil {
		key, err = h.keyFunc(key)
		if err != nil {
			return nil, err
		}
	}
	return h.handler.Get(key, args...)
}
249544
func (r *AppRepo) Get(id string) (*App, error) {
	app := &App{}

	if err := r.DB.Get(app, "SELECT * FROM apps WHERE id=$1", id); err != nil {
		if err == sql.ErrNoRows {
			return app, ErrAppNotExist
		}
		return app, err
	}

	return app, nil
}
1190178
func (s *LedisStore) Get(key interface{}) interface{} {
	s.lock.RLock()
	defer s.lock.RUnlock()

	return s.data[key]
}
786260
func Get(id string, params *stripe.SourceObjectParams) (*stripe.Source, error) {
	return getC().Get(id, params)
}
720551
func (c *EtcdLockClient) Get() (*Semaphore, error) {
	resp, err := c.keyapi.Get(context.Background(), c.keypath, nil)
	if err != nil {
		return nil, err
	}

	sem := &Semaphore{}
	err = json.Unmarshal([]byte(resp.Node.Value), sem)
	if err != nil {
		return nil, err
	}

	sem.Index = resp.Node.ModifiedIndex

	return sem, nil
}
1337034
func (l *Lock) Get() (sem *Semaphore, err error) {
	sem, err = l.client.Get()
	if err != nil {
		return nil, err
	}

	return sem, nil
}
218781
func (a *Allocator) Get(ctx context.Context, key AllocatorKey) (idpool.ID, error) {
	if id := a.mainCache.get(key.GetKey()); id != idpool.NoID {
		return id, nil
	}

	return a.GetNoCache(ctx, key)
}
81656
func (i *IdLock) Get(id string) sync.Locker {
	i.locksMu.Lock()
	defer i.locksMu.Unlock()

	var l sync.Locker
	var ok bool

	l, ok = i.locks[id]
	if !ok {
		l = &sync.Mutex{}
		i.locks[id] = l
	}

	return l
}