// Retrieve The starting hourly price for this configuration. Additional options not defined in the preset may increase the cost.
186818
func (r Product_Package_Preset) GetTotalMinimumHourlyFee() (resp datatypes.Float64, err error) {
	err = r.Session.DoRequest("SoftLayer_Product_Package_Preset", "getTotalMinimumHourlyFee", nil, &r.Options, &resp)
	return
}
798794
func (db *WiredDB) GetMempoolPriceCountTime() *apitypes.PriceCountTime {
	return db.MPC.GetTicketPriceCountTime(int(db.params.MaxFreshStakePerBlock))
}
1212244
func (o *AroundRadiusOption) Get() (int, string) {
	if o == nil || o.isAll {
		return 0, "all"
	}
	return o.meters, ""
}
984242
func (sh *SyncHandler) hourlyCompare(hourlyBytes uint64) {
	ctx := context.TODO()
	ticker := time.NewTicker(time.Hour).C
	for {
		content := make([]byte, 16)
		if _, err := rand.Read(content); err != nil {
			panic(err)
		}
		after := blob.RefFromBytes(content).String()
		var roundBytes uint64
		var roundBlobs int
		err := blobserver.EnumerateAllFrom(ctx, sh.from, after, func(sr blob.SizedRef) error {
			sh.mu.Lock()
			if _, ok := sh.needCopy[sr.Ref]; ok {
				sh.mu.Unlock()
				return nil // skip blobs in the copy queue
			}
			sh.mu.Unlock()

			if roundBytes+uint64(sr.Size) > hourlyBytes {
				return errStopEnumerating
			}
			blob, size, err := sh.to.(blob.Fetcher).Fetch(ctx, sr.Ref)
			if err != nil {
				return fmt.Errorf("error fetching %s: %v", sr.Ref, err)
			}
			if size != sr.Size {
				return fmt.Errorf("%s: expected size %d, got %d", sr.Ref, sr.Size, size)
			}
			h := sr.Ref.Hash()
			if _, err := io.Copy(h, blob); err != nil {
				return fmt.Errorf("error while reading %s: %v", sr.Ref, err)
			}
			if !sr.HashMatches(h) {
				return fmt.Errorf("expected %s, got %x", sr.Ref, h.Sum(nil))
			}

			sh.mu.Lock()
			sh.comparedBlobs++
			sh.comparedBytes += uint64(size)
			sh.compLastBlob = sr.Ref.String()
			sh.mu.Unlock()
			roundBlobs++
			roundBytes += uint64(size)
			return nil
		})
		sh.mu.Lock()
		if err != nil && err != errStopEnumerating {
			sh.compareErrors = append(sh.compareErrors, fmt.Sprintf("%s %v", time.Now(), err))
			sh.logf("!! hourly compare error !!: %v", err)
		}
		sh.comparedRounds++
		sh.mu.Unlock()
		sh.logf("compared %d blobs (%d bytes)", roundBlobs, roundBytes)
		<-ticker
	}
}
296374
func (ev *ChangeResp) GetValue(val proto.Message) (err error) {
	return ev.CurrVal.GetValue(val)
}
753412
func (r Billing_Currency) GetCurrentExchangeRate() (resp datatypes.Billing_Currency_ExchangeRate, err error) {
	err = r.Session.DoRequest("SoftLayer_Billing_Currency", "getCurrentExchangeRate", nil, &r.Options, &resp)
	return
}
223265
func (tl *TokenLimiter) effectiveRates(r request.Request) *RateSet {
	// If configuration mapper is not specified for this instance, then return
	// the default bucket specs.
	if tl.configMapper == nil {
		return tl.defaultRates
	}

	rates, err := tl.configMapper(r)
	if err != nil {
		log.Errorf("Failed to retrieve rates: %v", err)
		return tl.defaultRates
	}

	// If the returned rate set is empty then used the default one.
	if len(rates.m) == 0 {
		return tl.defaultRates
	}

	return rates
}
1185936
func (c *Client) GetRequestSetting(i *GetRequestSettingInput) (*RequestSetting, error) {
	if i.Service == "" {
		return nil, ErrMissingService
	}

	if i.Version == 0 {
		return nil, ErrMissingVersion
	}

	if i.Name == "" {
		return nil, ErrMissingName
	}

	path := fmt.Sprintf("/service/%s/version/%d/request_settings/%s", i.Service, i.Version, i.Name)
	resp, err := c.Get(path, nil)
	if err != nil {
		return nil, err
	}

	var b *RequestSetting
	if err := decodeJSON(&b, resp.Body); err != nil {
		return nil, err
	}
	return b, nil
}
684464
func (s ProcStat) StartTime() (float64, error) {
	stat, err := s.fs.NewStat()
	if err != nil {
		return 0, err
	}
	return float64(stat.BootTime) + (float64(s.Starttime) / userHZ), nil
}
168715
func (w *walletAPIHandler) getInflation(ctx context.Context, c Call, wr io.Writer) error {
	var opts accountIDOptions
	if err := unmarshalOptions(c, &opts); err != nil {
		return w.encodeErr(c, err, wr)
	}

	inflation, err := w.getInflationLocal(ctx, opts.Convert())
	if err != nil {
		return w.encodeErr(c, err, wr)
	}

	return w.encodeResult(c, inflation, wr)
}
791268
func (rules *ClientConfigLoadingRules) GetStartingConfig() (*clientcmdapi.Config, error) {
	clientConfig := NewNonInteractiveDeferredLoadingClientConfig(rules, &ConfigOverrides{})
	rawConfig, err := clientConfig.RawConfig()
	if os.IsNotExist(err) {
		return clientcmdapi.NewConfig(), nil
	}
	if err != nil {
		return nil, err
	}

	return &rawConfig, nil
}
286992
func (r Billing_Info) GetCurrency() (resp datatypes.Billing_Currency, err error) {
	err = r.Session.DoRequest("SoftLayer_Billing_Info", "getCurrency", nil, &r.Options, &resp)
	return
}
321630
func (m *managerImpl) GetConfiguration(throttlerName string) (map[string]*throttlerdatapb.Configuration, error) {
	m.mu.Lock()
	defer m.mu.Unlock()

	configurations := make(map[string]*throttlerdatapb.Configuration)

	if throttlerName != "" {
		t, ok := m.throttlers[throttlerName]
		if !ok {
			return nil, fmt.Errorf("throttler: %v does not exist", throttlerName)
		}
		configurations[throttlerName] = t.GetConfiguration()
		return configurations, nil
	}

	for name, t := range m.throttlers {
		configurations[name] = t.GetConfiguration()
	}
	return configurations, nil
}
347894
func (r Product_Package_Preset) GetConfiguration() (resp []datatypes.Product_Package_Preset_Configuration, err error) {
	err = r.Session.DoRequest("SoftLayer_Product_Package_Preset", "getConfiguration", nil, &r.Options, &resp)
	return
}
1318347
func (c *CreateCheckRunOptions) GetStartedAt() Timestamp {
	if c == nil || c.StartedAt == nil {
		return Timestamp{}
	}
	return *c.StartedAt
}
1054024
func (a DurationA) Get(vals ...interface{}) (val time.Duration) {
	v := get(a(0).arg(), vals)
	switch v := v.(type) {
	case *time.Duration:
		return *v
	case time.Duration:
		return v
	}
	return
}
1230586
func (table requestCostTable) getCost(code, amount uint64) uint64 {
	costs := table[code]
	return costs.baseCost + amount*costs.reqCost
}