// Get retrieves the pointer from the given handle
329843
func (v *HandleList) Get(handle unsafe.Pointer) interface{} {
	v.RLock()
	defer v.RUnlock()

	ptr, ok := v.handles[handle]
	if !ok {
		panic(fmt.Sprintf("invalid pointer handle: %p", handle))
	}

	return ptr
}
881369
func (t *Tango) Get(url string, c interface{}, middlewares ...Handler) {
	t.Route([]string{"GET", "HEAD:Get"}, url, c, middlewares...)
}
314650
func (b *CircularBuffer) Get() interface{} {
	_ = <-b.avail

	b.lock.Lock()
	defer b.lock.Unlock()

	if b.start == b.pos {
		panic("Trying to get from empty buffer")
	}

	v := b.buffer[b.start]
	b.buffer[b.start] = nil
	b.start = (b.start + 1) % b.size

	return v
}
352069
func (s *memoryStore) Get(parent, scope string) (string, error) {
	key := s.key(parent, scope)
	tok, ok := s.tokens[key]

	// token not set
	if !ok {
		return "", nil
	}

	// token set but expired, remove it from the map
	if time.Now().After(tok.Deadline) {
		delete(s.tokens, key)
		return "", nil
	}

	return tok.Token, nil
}
374107
func (r *Router) Get(path string, h http.HandlerFunc) {
	r.rtr.GET(r.prefix+path, r.handle(path, h))
}
696131
func (h *loaderHandler) Get(key string, args ...interface{}) (interface{}, error) {
	return h.handler.Get(key, args...)
}
802017
func (h *envHandler) Get(key string, args ...interface{}) (interface{}, error) {
	if len(args) != 0 {
		return "", cfg.ErrArgsNotSupported
	}
	val := os.Getenv(key)
	if val == "" {
		return val, cfg.ErrKeyNotFound
	}
	return val, nil
}
693002
func (cm *ContextMux) GET(path string, handler http.HandlerFunc) {
	cm.ContextGroup.Handle("GET", path, handler)
}
1021878
func (om *OrdMap) Get(key interface{}) interface{} {
	rkey := ty.AssertType(key, om.ktype)
	rval := om.m.MapIndex(rkey)
	if !rval.IsValid() {
		return om.zeroValue().Interface()
	}
	return rval.Interface()
}
934660
func (r *Router) GET(path string, mc MiddlewareChain, h Handler) {
	r.Handle("GET", path, mc, h)
}
1034646
func (d *Dtrie) Get(key interface{}) interface{} {
	return get(d.root, d.hasher(key), key).Value()
}
621924
func (r *Memory) Get(key string) (interface{}, error) {
	r.Lock()
	defer r.Unlock()

	return r.cache.Get(key)
}
427998
func Get() (p []byte, err error) {
	stdMu.Lock()
	defer stdMu.Unlock()
	if std == nil {
		std, err = NewProfiler()
		if err != nil {
			return nil, err
		}
	}
	return std.Get()
}
1094039
func (s *Server) Get(path string, h HandlerFunc, opts ...HandlerOption) {
	s.register(http.MethodGet, path, h, opts...)
}
506324
func (r *Router) Get(path string, fn http.HandlerFunc) *Router {
	return r.Method(http.MethodGet, path, fn)
}
1162869
func (b *Bucket) Get(key string, valuePtr interface{}) (Cas, error) {
	return b.get(key, valuePtr)
}
190100
func (g *Goon) Get(dst interface{}) error {
	set := reflect.ValueOf(dst)
	if set.Kind() != reflect.Ptr {
		return fmt.Errorf("goon: expected pointer to a struct, got %#v", dst)
	}
	if !set.CanSet() {
		set = set.Elem()
	}
	dsts := []interface{}{dst}
	if err := g.GetMulti(dsts); err != nil {
		// Look for an embedded error if it's multi
		if me, ok := err.(appengine.MultiError); ok {
			return me[0]
		}
		// Not multi, normal error
		return err
	}
	set.Set(reflect.Indirect(reflect.ValueOf(dsts[0])))
	return nil
}