// Get returns LoadAvg populated with the 1, 5, and 15 minute values.
486248
func Get() (LoadAvg, error) {
	var l LoadAvg
	err := l.Get()
	return l, err
}
775219
func (s *inMemoryStore) Get(ctx context.Context, h types.Metric, resetTime time.Time, fieldVals []interface{}) interface{} {
	if resetTime.IsZero() {
		resetTime = clock.Now(ctx)
	}

	m := s.getOrCreateData(h)
	m.lock.Lock()
	defer m.lock.Unlock()

	return m.get(fieldVals, target.Get(ctx), resetTime).Value
}
1217787
func Get() (p []byte, err error) {
	var l load.LoadAvg
	err = l.Get()
	if err != nil {
		return nil, err
	}
	return json.Marshal(&l)
}
1180706
func (c *Client) Get(uri string, timeout time.Duration) ([]byte, error) {
	if timeout < 0 {
		timeout = 0
	}
	reader, err := c.Do(uri, timeout, false)
	if err != nil {
		return nil, err
	}
	defer reader.Close()
	return ioutil.ReadAll(reader)
}
53070
func Get() (p []byte, err error) {
	var u up.Uptime
	err = u.Get()
	if err != nil {
		return nil, err
	}
	return Serialize(&u), nil
}
711643
func (s *Fake) Get(context.Context, types.Metric, time.Time, []interface{}) interface{} {
	return nil
}
127893
func (v *Value) Get(dirty ...bool) (value interface{}, err error) {
	if v.value != nil && time.Now().Before(v.next) {
		return v.value, nil
	}

	v.locker.Lock()
	defer v.locker.Unlock()

	if v.value != nil && time.Now().Before(v.next) {
		return v.value, nil
	}

	value, err = v.Load()
	if err == nil {
		ttl := v.TTL
		if ttl == 0 {
			ttl = time.Hour
		}
		v.value, v.next = value, time.Now().Add(ttl)
	} else {
		if v.value != nil && (len(dirty) > 0 && dirty[0]) {
			return v.value, nil
		}
	}
	return
}
155293
func (m *Mat64Instances) Get(as AttributeSpec, row int) []byte {
	val := m.Data.At(row, as.position)
	return PackFloatToBytes(val)
}
616631
func (al *assetLru) Get(key int64) (value *assetCache, ok bool) {
	if ele, hit := al.cache[key]; hit {
		al.ll.MoveToFront(ele)
		return ele.Value.value, true
	}
	return
}
38588
func (c *Cache) Get(_ context.Context, key dataloader.Key) (dataloader.Thunk, bool) {
	v, ok := c.c.Get(key.String())
	if ok {
		return v.(dataloader.Thunk), ok
	}
	return nil, ok
}
343541
func (c *Config) Get(key string) (string, error) {
	data, err := load(c.filename, c.passphrase)
	return data[key], err
}
933099
func Get() (u Uptime, err error) {
	stdMu.Lock()
	defer stdMu.Unlock()
	if std == nil {
		std, err = NewProfiler()
		if err != nil {
			return u, err
		}
	}
	return std.Get()
}
601134
func Get(url string, v ...interface{}) (*Resp, error) {
	return std.Get(url, v...)
}
1248099
func (_m *RequesterVariadic) Get(values ...string) bool {
	_va := make([]interface{}, len(values))
	for _i := range values {
		_va[_i] = values[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 bool
	if rf, ok := ret.Get(0).(func(...string) bool); ok {
		r0 = rf(values...)
	} else {
		r0 = ret.Get(0).(bool)
	}

	return r0
}
696131
func (h *loaderHandler) Get(key string, args ...interface{}) (interface{}, error) {
	return h.handler.Get(key, args...)
}
823875
func (h *multiHandler) Get(key string, args ...interface{}) (interface{}, error) {
	lengthArgs := len(args)
	if lengthArgs > 0 && !h.Args() {
		return nil, cfg.ErrArgsNotSupported
	}

	for _, handler := range h.handlers {
		switch {
		case lengthArgs != 0 && handler.Args():
			if val, err := handler.Get(key, args...); err == nil {
				return val, nil
			}
		default:
			if val, err := handler.Get(key); err == nil {
				return val, nil
			}
		}
	}
	return nil, cfg.ErrKeyNotFound
}
305224
func (s *store) Get(ctx context.Context, key string, resourceVersion string, out runtime.Object, ignoreNotFound bool) error {
	key = path.Join(s.pathPrefix, key)
	startTime := time.Now()
	getResp, err := s.client.KV.Get(ctx, key, s.getOps...)
	metrics.RecordEtcdRequestLatency("get", getTypeName(out), startTime)
	if err != nil {
		return err
	}

	if len(getResp.Kvs) == 0 {
		if ignoreNotFound {
			return runtime.SetZeroValue(out)
		}
		return storage.NewKeyNotFoundError(key, 0)
	}
	kv := getResp.Kvs[0]

	data, _, err := s.transformer.TransformFromStorage(kv.Value, authenticatedDataString(key))
	if err != nil {
		return storage.NewInternalError(err.Error())
	}

	return decode(s.codec, s.versioner, data, out, kv.ModRevision)
}