// Retrieve retrieves the keys from the environment.
171697
func (e *EnvMinio) Retrieve() (Value, error) {
	e.retrieved = false

	id := os.Getenv("MINIO_ACCESS_KEY")
	secret := os.Getenv("MINIO_SECRET_KEY")

	signerType := SignatureV4
	if id == "" || secret == "" {
		signerType = SignatureAnonymous
	}

	e.retrieved = true
	return Value{
		AccessKeyID:     id,
		SecretAccessKey: secret,
		SignerType:      signerType,
	}, nil
}
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
}
764941
func (c *Context) Get(key string) string {
	c.lock.RLock()
	defer c.lock.RUnlock()
	if v, ok := c.contextMap[key]; ok {
		return v.(string)
	}
	return ""
}
141484
func (r *GenResult) Retrieve() (interface{}, bool) {
	if (r.Sieve == nil && r.Result != nil) || (r.Sieve != nil && r.Sieve(r.Result)) {
		return r.Result, true
	}
	return nil, false
}
338158
func (v ContainerView) Retrieve(ctx context.Context, kind []string, ps []string, dst interface{}) error {
	pc := property.DefaultCollector(v.Client())

	ospec := types.ObjectSpec{
		Obj:  v.Reference(),
		Skip: types.NewBool(true),
		SelectSet: []types.BaseSelectionSpec{
			&types.TraversalSpec{
				Type: v.Reference().Type,
				Path: "view",
			},
		},
	}

	var pspec []types.PropertySpec

	if len(kind) == 0 {
		kind = []string{"ManagedEntity"}
	}

	for _, t := range kind {
		spec := types.PropertySpec{
			Type: t,
		}

		if len(ps) == 0 {
			spec.All = types.NewBool(true)
		} else {
			spec.PathSet = ps
		}

		pspec = append(pspec, spec)
	}

	req := types.RetrieveProperties{
		SpecSet: []types.PropertyFilterSpec{
			{
				ObjectSet: []types.ObjectSpec{ospec},
				PropSet:   pspec,
			},
		},
	}

	res, err := pc.RetrieveProperties(ctx, req)
	if err != nil {
		return err
	}

	if d, ok := dst.(*[]types.ObjectContent); ok {
		*d = res.Returnval
		return nil
	}

	return mo.LoadRetrievePropertiesResponse(res, dst)
}
30650
func (b Base) Retrieve(url string) (*os.File, error) {
	return nil, errors.New("not implemented")
}
341390
func (it *NodeIterator) retrieve() bool {
	// Clear out any previously set values
	it.Hash = common.Hash{}

	// If the iteration's done, return no available data
	if it.state == nil {
		return false
	}
	// Otherwise retrieve the current entry
	switch {
	case it.dataIt != nil:
		it.Hash, it.Parent = it.dataIt.Hash(), it.dataIt.Parent()
		if it.Parent == (common.Hash{}) {
			it.Parent = it.accountHash
		}
	case it.code != nil:
		it.Hash, it.Parent = it.codeHash, it.accountHash
	case it.stateIt != nil:
		it.Hash, it.Parent = it.stateIt.Hash(), it.stateIt.Parent()
	}
	return true
}
1121944
func (rkv *KeyValue) Get(key string) (string, error) {
	conn := rkv.pool.Get(rkv.dbindex)
	result, err := redis.String(conn.Do("GET", rkv.id+":"+key))
	if err != nil {
		return "", err
	}
	return result, nil
}
1128219
func (rc *Redis) Get(key string) (interface{}, error) {
	val, err := rc.do("GET", key)
	if err != nil {
		if rc.Debug {
			log.Println("[Redis]GetErr: ", err, "Key:", key)
		}
		return nil, err
	}
	var v interface{}
	err = Decode(val.([]byte), &v)
	if err != nil {
		if rc.Debug {
			log.Println("[Redis]DecodeErr: ", err, "Key:", key)
		}
		return nil, err
	}
	if rc.Debug {
		log.Println("[Redis]Get: ", key)
	}
	return v, err
}
799905
func (environmentApi *EnvironmentApi) Get(id string) (*Environment, error) {
	data, err := environmentApi.configurationService.Get(id, map[string]string{})
	if err != nil {
		return nil, err
	}
	return parseEnvironment(data), nil
}
570254
func (s *CacheOnStorage) Get(key interface{}) (interface{}, error) {
	if item, err := s.cache.Get(key); err != nil {
		return nil, err
	} else if item != nil {
		return item, nil
	}

	item, err := s.storage.Get(key)
	if err != nil {
		return nil, err
	}

	if err := s.cache.Set(item); err != nil {
		// XXX: Maybe make this a non error
		return nil, err
	}
	return item, nil
}
876099
func (km *KeyManager) Get(k Key) KeyState {
	km.mutex.RLock()
	ks := km.mapper[k]
	km.mutex.RUnlock()

	return ks
}
498215
func (ed *EtcdDriver) Retrieve(path string) string {
	return findEtcdNode(ed.response.Node.Nodes, path)
}
944756
func (environment) Get(key, defaultValue string) string {
	if v, ok := os.LookupEnv(key); ok {
		return v
	}
	return defaultValue
}
222979
func (c *LRU) Get(key interface{}) (value interface{}, ok bool) {
	if ent, ok := c.items[key]; ok {
		c.evictList.MoveToFront(ent)
		return ent.Value.(*entry).value, true
	}
	return
}
1232941
func (p Provider) Retrieve() (credentials.Value, error) {
	creds := credentials.Value{
		ProviderName: ProviderName,
	}

	k, s, t, err := p.RetrieveFn()
	if err != nil {
		return creds, awserr.New(ErrCodePluginProviderRetrieve,
			"failed to retrieve credentials with plugin provider", err)
	}

	creds.AccessKeyID = k
	creds.SecretAccessKey = s
	creds.SessionToken = t

	return creds, nil
}
376723
func (c *Client) Get(key string) (string, error) {
	var s string
	err := c.command(&s,
		[]byte("GET"),
		[]byte(key),
	)
	return s, err
}