// Get returns latest media from timeline.
//
// For pagination use FeedMedia.Next()
355254
func (time *Timeline) Get() *FeedMedia {
	insta := time.inst
	media := &FeedMedia{}
	media.inst = insta
	media.endpoint = urlTimeline
	return media
}
327778
func (l *LRUCache) Get(url string, time time.Time) (content *FantasyContent, ok bool) {
	value, ok := l.Cache.Get(l.getKey(url, time))
	if !ok {
		return nil, ok
	}
	lruCacheValue, ok := value.(*LRUCacheValue)
	if !ok {
		return nil, ok
	}
	return lruCacheValue.content, true
}
863041
func (b *backups) Get(id string) (*Metadata, io.ReadCloser, error) {
	if strings.Contains(id, TempFilename) {
		return b.getArchiveFromFilename(id)
	}
	rawmeta, archiveFile, err := b.storage.Get(id)
	if err != nil {
		return nil, nil, errors.Trace(err)
	}

	meta, ok := rawmeta.(*Metadata)
	if !ok {
		return nil, nil, errors.New("did not get a backups.Metadata value from storage")
	}

	return meta, archiveFile, nil
}
622493
func (p JSPointer) Get(item interface{}) (interface{}, error) {
	var ctx matchCtx

	ctx.raw = p.raw
	ctx.tokens = &p.tokens
	ctx.apply(item)
	return ctx.result, ctx.err
}
1220779
func (p *MemoryPurse) Get(filename string) (v string, ok bool) {
	p.mu.RLock()
	v, ok = p.files[filename]
	p.mu.RUnlock()
	return
}
656050
func (s *RedisFrameHistory) Get() (out []*Frame, err error) {
	frames, err := s.store.GetFront(s.key(), FramesHistorySize)
	for _, frameStr := range frames {
		frame := new(Frame)
		if err := json.Unmarshal([]byte(frameStr), frame); err != nil {
			return nil, err
		}
		out = append(out, frame)
	}
	return
}
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)
}
939261
func (s *Service) get(w http.ResponseWriter, r *http.Request, _ mux.Params) {
	key := []byte(r.URL.String())
	value, err := s.todos.Get(key)
	if err != nil {
		http.Error(w, err.Error(), 500)
	}
	w.Header().Set("Content-Type", "application/json")
	w.Write(value)
}
1174844
func (s *GRPCStorage) Get(ctx context.Context, fn *FileNameMsg) (*ByteMsg, error) {
	data, err := s.backend.Get(fn.FileName)
	if err != nil {
		return &ByteMsg{}, err
	}
	return &ByteMsg{Data: data}, nil
}
1013129
func (c *Client) Get(ctx context.Context, url string) (*http.Response, error) {
	req, err := http.NewRequest("GET", url, nil)
	if err != nil {
		return nil, err
	}

	return c.Do(ctx, req)
}
1058508
func (a AuxFields) Get(tag Tag) Aux {
	for _, f := range a {
		if f.Tag() == tag {
			return f
		}
	}
	return nil
}
772115
func (c *Client) Get() *bytes.Buffer {
	b := <-c.p.ch
	b.Reset()
	c.sent <- b
	return b
}
771997
func (c *Client) Get(url string) (*http.Response, error) {
	get := func(args ...interface{}) (*http.Response, error) {
		return c.HTTPClient.Get(args[0].(string))
	}

	resp, err := c.HTTPClient.Get(url)
	if err != nil {
		if c.ExponentialBackoff {
			return c.backoff(get, url)
		}
		return nil, err
	}

	if resp.StatusCode >= http.StatusInternalServerError && c.ExponentialBackoff {
		return c.backoff(get, url)
	}

	return resp, err
}
193180
func (obj *Doc) GetMediaList(ctx context.Context) (*MediaList, error) {
	result := &struct {
		List *MediaList	`json:"qList"`
		Return bool	`json:"qReturn"`
	} {}
	err := obj.rpc(ctx, "GetMediaList", result)
	return result.List, err 
}
1124701
func (s *SourcesStore) Get(ctx context.Context, ID int) (chronograf.Source, error) {
	return s.GetF(ctx, ID)
}
539265
func (s *imageReviewLister) Get(name string) (*v1alpha1.ImageReview, error) {
	obj, exists, err := s.indexer.GetByKey(name)
	if err != nil {
		return nil, err
	}
	if !exists {
		return nil, errors.NewNotFound(v1alpha1.Resource("imagereview"), name)
	}
	return obj.(*v1alpha1.ImageReview), nil
}
1171953
func (f *FIFO) Get(obj interface{}) (item interface{}, exists bool, err error) {
	key, err := f.keyFunc(obj)
	if err != nil {
		return nil, false, KeyError{obj, err}
	}
	return f.GetByKey(key)
}