//DefaultDecider is a 'catch-all' decider that simply logs the unhandled decision.
//You should place this or one like it as the last decider in your top level ComposableDecider.
421072
func DefaultDecider() Decider {
	return func(ctx *FSMContext, h HistoryEvent, data interface{}) Outcome {
		log.Printf("at=unhandled-event event=%s state=%s default=stay decisions=0", h.EventType, ctx.State)
		return ctx.Stay(data, ctx.EmptyDecisions())
	}
}
1122056
func (s *DateArrayOptions) SetDefaultValue(v string) *DateArrayOptions {
	s.DefaultValue = &v
	return s
}
1187839
func NewDefaultCleaner(fs fs.FileSystem, docker docker.Docker) Cleaner {
	return &DefaultCleaner{
		fs:     fs,
		docker: docker,
	}
}
208439
func DefaultAfter(entry *logrus.Entry, res negroni.ResponseWriter, latency time.Duration, name string) *logrus.Entry {
	return entry.WithFields(logrus.Fields{
		"status":      res.Status(),
		"text_status": http.StatusText(res.Status()),
		"took":        latency,
		fmt.Sprintf("measure#%s.latency", name): latency.Nanoseconds(),
	})
}
422180
func (f genHelperDecoder) DecFallback(iv interface{}, chkPtr bool) {
	// println(">>>>>>>>> DecFallback")
	rv := reflect.ValueOf(iv)
	if chkPtr {
		rv = f.d.ensureDecodeable(rv)
	}
	f.d.decodeValue(rv, nil, false)
	// f.d.decodeValueFallback(rv)
}
458794
func (s *ProvisioningArtifactParameter) SetDefaultValue(v string) *ProvisioningArtifactParameter {
	s.DefaultValue = &v
	return s
}
569462
func NewDefaultLogger(Level LogLevel) *DefaultLogger {
	var config = fmt.Sprintf(`<seelog minlevel="%s">
    <outputs formatid="main">
        <console />
    </outputs>

    <formats>
        <format id="main" format="%%Date/%%Time [%%LEVEL] %%Msg%%n"/>
    </formats>
</seelog>`, Level)
	logger, _ := log.LoggerFromConfigAsBytes([]byte(config))
	return &DefaultLogger{Level, logger}
}
959633
func Default() Func {
	f, err := New(&defaultPolicy)
	if err != nil {
		panic(fmt.Errorf("failed to instantiate default triggering policy - %s", err))
	}
	return f
}
482376
func (m *Manager) SetDefaultValue(name string, value interface{}) {
	coverOption(m.defaults, name, value)
}
980210
func debouncer(doit chan<- struct{}, needitdone <-chan struct{}, threshold time.Duration, sleepTime time.Duration) {
	var oldestNeedItDone time.Time

	for {
		select {
		case <-needitdone:
			if oldestNeedItDone.IsZero() {
				oldestNeedItDone = now()
			}
		default:
			// This sleep time is the max error that we'll be off by.
			time.Sleep(sleepTime)
		}

		if !oldestNeedItDone.IsZero() && (now().Sub(oldestNeedItDone) > threshold) {
			doit <- struct{}{}
			oldestNeedItDone = time.Time{} // Zero the object
		}
	}
}
69655
func (f *FSM) DefaultTaskErrorHandler(decisionTask *swf.PollForDecisionTaskOutput, err error) {
	f.log("workflow=%s workflow-id=%s run-id=%s action=tick at=handle-task-error status=abandoning-task error=%q", s.LS(decisionTask.WorkflowType.Name), s.LS(decisionTask.WorkflowExecution.WorkflowId), s.LS(decisionTask.WorkflowExecution.RunId), err.Error())
}
287045
func (s *IntOptions) SetDefaultValue(v int64) *IntOptions {
	s.DefaultValue = &v
	return s
}
433955
func (l *Label) GetDefault() bool {
	if l == nil || l.Default == nil {
		return false
	}
	return *l.Default
}
296149
func SetDefaultInt(in int64) integerRuleOpt {
	return func(i *rpc.IntegerRule) {
		i.Default = in
		i.HasDefault = true
	}
}
1182359
func (a Addr) Default() Addr {
	if err := a.Set(a.Value); err != nil {
		panic(err)
	}
	a.Provided = false
	return a
}
1020993
func (ic *IntegerConstraint) Default(v interface{}) *IntegerConstraint {
	ic.NumberConstraint.Default(v)
	return ic
}
331454
func (s *DistributionConfig) SetDefaultCacheBehavior(v *DefaultCacheBehavior) *DistributionConfig {
	s.DefaultCacheBehavior = v
	return s
}