// GetHighlights returns the IDs of all currently highlighted regions.
346848
func (t *TextView) GetHighlights() (regionIDs []string) {
	for id := range t.highlights {
		regionIDs = append(regionIDs, id)
	}
	return
}
274091
func (c *Client) GetLightByID(id uint64) (light common.Light, err error) {
	dev, err := c.GetDeviceByID(id)
	if err != nil {
		return nil, err
	}

	light, ok := dev.(common.Light)
	if !ok {
		return nil, common.ErrDeviceInvalidType
	}

	return light, nil
}
735297
func (list *List) HighlightUp() *List {

	// If there is no where to go
	if 0 >= list.Index-1 {
		return list
	}

	list.Cursor.EraseCurrentLine()
	list.PrintOption(list.options[list.Index-1])

	list.Cursor.MoveUp(1)

	list.Cursor.EraseCurrentLine()
	list.Index--
	list.PrintHighlight(list.options[list.Index-1])

	return list
}
752153
func (c *Cluster) getRegionsCoverRange(start, end MvccKey) []*Region {
	regions := make([]*Region, 0, len(c.regions))
	for _, region := range c.regions {
		onRight := bytes.Compare(end, region.Meta.StartKey) <= 0
		onLeft := bytes.Compare(region.Meta.EndKey, start) <= 0
		if len(region.Meta.EndKey) == 0 {
			onLeft = false
		}
		if onLeft || onRight {
			continue
		}
		regions = append(regions, region)
	}
	return regions
}
1145510
func (fs *FSObjects) getMultipartSHADir(bucket, object string) string {
	return pathJoin(fs.fsPath, minioMetaMultipartBucket, getSHA256Hash([]byte(pathJoin(bucket, object))))
}
1357731
func ExtractReplaceSynonymsInHighlight(opts ...interface{}) *opt.ReplaceSynonymsInHighlightOption {
	for _, o := range opts {
		if v, ok := o.(*opt.ReplaceSynonymsInHighlightOption); ok {
			return v
		}
	}
	return nil
}
116244
func (a *SetInspectModeArgs) SetHighlightConfig(highlightConfig HighlightConfig) *SetInspectModeArgs {
	a.HighlightConfig = &highlightConfig
	return a
}
1232579
func (user *User) Highlights() ([]StoryMedia, error) {
	query := []trayRequest{
		{"SUPPORTED_SDK_VERSIONS", "9.0,10.0,11.0,12.0,13.0,14.0,15.0,16.0,17.0,18.0,19.0,20.0,21.0,22.0,23.0,24.0"},
		{"FACE_TRACKER_VERSION", "10"},
		{"segmentation", "segmentation_enabled"},
		{"COMPRESSION", "ETC2_COMPRESSION"},
	}
	data, err := json.Marshal(query)
	if err != nil {
		return nil, err
	}
	body, err := user.inst.sendRequest(
		&reqOptions{
			Endpoint: fmt.Sprintf(urlUserHighlights, user.ID),
			Query:    generateSignature(b2s(data)),
		},
	)
	if err == nil {
		tray := &Tray{}
		err = json.Unmarshal(body, &tray)
		if err == nil {
			tray.set(user.inst, "")
			for i := range tray.Stories {
				if len(tray.Stories[i].Items) == 0 {
					err = tray.Stories[i].Sync()
					if err != nil {
						return nil, err
					}
				}
			}
			return tray.Stories, nil
		}
	}
	return nil, err
}
895298
func (ts *Server) GetKnownCells(ctx context.Context) ([]string, error) {
	// Note we use the global read-only cell here, as the result
	// is not time sensitive.
	entries, err := ts.globalReadOnlyCell.ListDir(ctx, CellsPath, false /*full*/)
	if err != nil {
		return nil, err
	}
	return DirEntriesToStringArray(entries), nil
}
1294118
func (sf *StdFormatter) levelHeaders() LevelMap {
	switch {
	case sf.NoColors:
		return sf.HeaderPlain
	case sf.Colors:
		return sf.HeaderColor
	case sf.colorSupported:
		return sf.HeaderColor
	}
	return sf.HeaderPlain
}
850325
func (c *Overlay) HighlightQuadWithParams(v *OverlayHighlightQuadParams) (*gcdmessage.ChromeResponse, error) {
	return gcdmessage.SendDefaultRequest(c.target, c.target.GetSendCh(), &gcdmessage.ParamRequest{Id: c.target.GetId(), Method: "Overlay.highlightQuad", Params: v})
}
123489
func (c *Client) GetLights() (lights []common.Light, err error) {
	devices, err := c.GetDevices()
	if err != nil {
		return lights, err
	}

	for _, dev := range devices {
		if light, ok := dev.(common.Light); ok {
			lights = append(lights, light)
		}
	}

	if len(lights) == 0 {
		return lights, common.ErrNotFound
	}

	return lights, nil
}
984130
func (bot *BotAPI) GetGameHighScores(config GetGameHighScoresConfig) ([]GameHighScore, error) {
	v, _ := config.values()

	resp, err := bot.MakeRequest(config.method(), v)
	if err != nil {
		return []GameHighScore{}, err
	}

	var highScores []GameHighScore
	err = json.Unmarshal(resp.Result, &highScores)

	return highScores, err
}
384342
func (a *Authorization) GetTokenLastEight() string {
	if a == nil || a.TokenLastEight == nil {
		return ""
	}
	return *a.TokenLastEight
}
159841
func (l *Client) GetSegments(table string) ([]*Segment, error) {
	res := ApiResp{}
	data := []*Segment{}
	params := url.Values{}

	params.Add("table", table)

	// make the request
	err := l.Get(segmentListEndpoint, params, nil, &res, &data)
	if err != nil {
		return data, err
	}

	return data, nil
}
495473
func (*environProvider) DetectRegions() ([]cloud.Region, error) {
	// For now we just return a hard-coded "localhost" region,
	// i.e. the local LXD daemon. We may later want to detect
	// locally-configured remotes.
	return []cloud.Region{{Name: lxdnames.DefaultLocalRegion}}, nil
}
800585
func (r *SearchRequest) Highlight(highlight *Highlight) *SearchRequest {
	r.searchSource = r.searchSource.Highlight(highlight)
	return r
}