// Retrieve The hour parameter of this schedule.
506431
func (r Network_Storage_Schedule) GetDay() (resp string, err error) {
	err = r.Session.DoRequest("SoftLayer_Network_Storage_Schedule", "getDay", nil, &r.Options, &resp)
	return
}
1351046
func (c *config) GetTime(key string, args ...interface{}) time.Time {
	val, err := c.GetTimeErr(key, args...)
	if err != nil {
		c.errorHandler(key, err, args...)
	}
	return val
}
832842
func (prof *Profiler) Get() (u Uptime, err error) {
	err = prof.Reset()
	if err != nil {
		return u, err
	}
	var i int
	var v byte
	u.Timestamp = time.Now().UTC().UnixNano()
	for {
		prof.Line, err = prof.ReadSlice('\n')
		if err != nil {
			if err == io.EOF {
				break
			}
			return u, &joe.ReadError{Err: err}
		}
		// space delimits the two values
		for i, v = range prof.Line {
			if v == 0x20 {
				break
			}
		}
		u.Total, err = strconv.ParseFloat(string(prof.Line[:i]), 64)
		if err != nil {
			return u, &joe.ParseError{Info: "total", Err: err}
		}
		u.Idle, err = strconv.ParseFloat(string(prof.Line[i+1:len(prof.Line)-1]), 64)
		if err != nil {
			return u, &joe.ParseError{Info: "idle", Err: err}
		}

	}
	return u, nil
}
1076675
func GetTime(key string, args ...interface{}) time.Time {
	return std.GetTime(key, args...)
}
269809
func (o *LocaleOptions) getParameters() (params map[string]string, err error) {
	params = make(map[string]string)
	if o.cc != "" {
		params["cc"] = o.cc
	}
	if o.lang != "" {
		params["lang"] = o.lang
	}
	return params, nil
}
1065054
func Time(name string, out *time.Time, predicates ...Predicate) Param {
	return func(r *http.Request) error {
		for _, p := range predicates {
			if err := p.Pass(name, r); err != nil {
				return err
			}
		}
		v := r.Form.Get(name)
		if v == "" {
			return nil
		}
		var t time.Time
		if err := t.UnmarshalText([]byte(v)); err != nil {
			return &BadParameterError{Param: name, Message: err.Error()}
		}
		*out = t
		return nil
	}
}
1115842
func getWaitTime(now time.Time, maxWait time.Duration) time.Duration {
	wait := nextProvision.Sub(now) // might be negative

	// When the system clock falls back an hour, the wait time might be an hour.
	// This sanity check prevents this error.
	if wait > maxWait {
		return maxWait
	}
	if wait < 0 {
		return 0
	}
	return wait
}
381648
func (bridge *Bridge) GetSchedule(id string) (Schedule, error) {
	uri := fmt.Sprintf("/api/%s/schedules/%s", bridge.Username, id)
	body, _, err := bridge.Get(uri)
	if err != nil {
		return Schedule{}, err
	}

	schedule := Schedule{}
	err = json.Unmarshal(body, &schedule)
	if err != nil {
		return Schedule{}, err
	}
	return schedule, nil
}
572890
func (n *NullTime) Get() *time.Time {
	if !n.Valid {
		return nil
	}

	return &n.Time
}
798463
func (c Client) Get(id string, params *stripe.SubscriptionScheduleRevisionParams) (*stripe.SubscriptionScheduleRevision, error) {
	if params == nil {
		return nil, fmt.Errorf("params cannot be nil")
	}
	if params.Schedule == nil {
		return nil, fmt.Errorf("params.Schedule must be set")
	}

	path := stripe.FormatURLPath("/v1/subscription_schedules/%s/revisions/%s",
		stripe.StringValue(params.Schedule), id)
	rev := &stripe.SubscriptionScheduleRevision{}
	err := c.B.Call(http.MethodGet, path, c.Key, params, rev)
	return rev, err
}
327037
func getModTime(path string) (t time.Time, err *probe.Error) {
	var e error
	path, e = filepath.EvalSymlinks(path)
	if e != nil {
		return t, probe.NewError(fmt.Errorf("Unable to get absolute path of %s. %s", path, e))
	}

	// Version is mc non-standard, we will use mc binary's
	// ModTime as release time.
	var fi os.FileInfo
	fi, e = os.Stat(path)
	if e != nil {
		return t, probe.NewError(fmt.Errorf("Unable to get ModTime of %s. %s", path, e))
	}

	// Return the ModTime
	return fi.ModTime().UTC(), nil
}
756405
func GetSchedulerProbeAddress(cfg *kubeadmapi.ClusterConfiguration) string {
	if addr, exists := cfg.Scheduler.ExtraArgs[kubeSchedulerAddressArg]; exists {
		return addr
	}
	return "127.0.0.1"
}
446986
func CpuRestGetSumTime(context *gin.Context) {
	body, err := cpu.ServiceGetSummaryTime()
	util.RestHandleResponse(context, body, err)
}
454492
func (r Account) GetAverageArchiveUsageMetricDataByDate(startDateTime *datatypes.Time, endDateTime *datatypes.Time) (resp datatypes.Float64, err error) {
	params := []interface{}{
		startDateTime,
		endDateTime,
	}
	err = r.Session.DoRequest("SoftLayer_Account", "getAverageArchiveUsageMetricDataByDate", params, &r.Options, &resp)
	return
}
752803
func (_m *Getter) GetStatInterval() time.Duration {
	ret := _m.Called()

	var r0 time.Duration
	if rf, ok := ret.Get(0).(func() time.Duration); ok {
		r0 = rf()
	} else {
		r0 = ret.Get(0).(time.Duration)
	}

	return r0
}
130422
func GetTimeBytes(buf []byte, hour int, min int, sec int) []byte {
	p := hour << 1
	buf[0] = digit2[p]
	buf[1] = digit2[p+1]
	p = min << 1
	buf[2] = digit2[p]
	buf[3] = digit2[p+1]
	p = sec << 1
	buf[4] = digit2[p]
	buf[5] = digit2[p+1]
	return buf[:6]
}
7343
func GetBootTime() (time.Time, error) {
	currentTime := time.Now()
	output, _, err := tickCount.Call()
	if errno, ok := err.(syscall.Errno); !ok || errno != 0 {
		return time.Time{}, err
	}
	return currentTime.Add(-time.Duration(output) * time.Millisecond).Truncate(time.Second), nil
}