// AddReturnRule adds a return rule for the chain in the filter table
770746
func AddReturnRule(chain string) error {
	var (
		table = Filter
		args  = []string{"-j", "RETURN"}
	)

	if Exists(table, chain, args...) {
		return nil
	}

	err := RawCombinedOutput(append([]string{"-A", chain}, args...)...)
	if err != nil {
		return fmt.Errorf("unable to add return rule in %s chain: %s", chain, err.Error())
	}

	return nil
}
324283
func (a *EvaluateArgs) SetReturnByValue(returnByValue bool) *EvaluateArgs {
	a.ReturnByValue = &returnByValue
	return a
}
1162392
func (s *QueryInput) SetReturnConsumedCapacity(v string) *QueryInput {
	s.ReturnConsumedCapacity = &v
	return s
}
432683
func (s *GetItemInput) SetReturnConsumedCapacity(v string) *GetItemInput {
	s.ReturnConsumedCapacity = &v
	return s
}
662874
func (d DefaultRetryer) RetryRules(r *request.Request) time.Duration {
	// Set the upper limit of delay in retrying at ~five minutes
	minTime := 30
	throttle := d.shouldThrottle(r)
	if throttle {
		if delay, ok := getRetryDelay(r); ok {
			return delay
		}

		minTime = 500
	}

	retryCount := r.RetryCount
	if throttle && retryCount > 8 {
		retryCount = 8
	} else if retryCount > 13 {
		retryCount = 13
	}

	delay := (1 << uint(retryCount)) * (sdkrand.SeededRand.Intn(minTime) + minTime)
	return time.Duration(delay) * time.Millisecond
}
706243
func (c *Chain) Add(filter interface{}) {
	switch filter.(type) {
	case Filter:
		break
	case FilterFunc:
		break
	case func(*Update) bool:
		break
	default:
		panic("telebot: unsupported filter type")
	}

	c.Filters = append(c.Filters, filter)
}
1062246
func (s *Selection) AddBackMatcher(m Matcher) *Selection {
	return s.AddSelection(s.prevSel.FilterMatcher(m))
}
1226413
func (element *Element) addStyleRule(styleRule *StyleRule) {
	element.styleRules = append(element.styleRules, styleRule)
}
393641
func (client *BaseClient) AddFilter(filter ...Filter) Client {
	client.filterManager.AddFilter(filter...)
	return client
}
72626
func (s *SendTemplatedEmailInput) SetReturnPathArn(v string) *SendTemplatedEmailInput {
	s.ReturnPathArn = &v
	return s
}
14586
func (c *ConfigPolicy) AddNewStringRule(ns []string, key string, req bool, opts ...stringRuleOpt) error {
	if key == "" {
		return ErrEmptyKey
	}
	rule := &rpc.StringRule{
		Required: req,
	}

	for _, opt := range opts {
		opt(rule)
	}
	k := strings.Join(ns, ".") // Method used in daemon/ctree
	if c.stringRules[k] == nil {
		c.stringRules[k] = &rpc.StringPolicy{
			Rules: map[string]*rpc.StringRule{},
			Key:   ns,
		}
	}
	c.stringRules[k].Rules[key] = rule
	return nil
}
368421
func (hm *handlerManager) AddAfterFilterHandler(handler ...FilterHandler) {
	if len(handler) == 0 {
		return
	}
	hm.afterFilterHandlers = append(hm.afterFilterHandlers, handler...)
	next := hm.defaultAfterFilterHandler
	for i := len(hm.afterFilterHandlers) - 1; i >= 0; i-- {
		next = getNextFilterHandler(next, hm.afterFilterHandlers[i])
	}
	hm.afterFilterHandler = next
}
1172926
func (c *Debugger) SetReturnValue(newValue *RuntimeCallArgument) (*gcdmessage.ChromeResponse, error) {
	var v DebuggerSetReturnValueParams
	v.NewValue = newValue
	return c.SetReturnValueWithParams(&v)
}
336387
func (h *ClientHandler) AddRule(r rule.Rule) *ClientHandler {
	if r == nil {
		return h
	}

	h.rule = rule.Chained(h.rule, r)
	return h
}
2589
func (fm *filterManager) AddFilter(filter ...Filter) {
	fm.fmLocker.Lock()
	fm.addFilter(filter...)
	fm.fmLocker.Unlock()
}
1113122
func (a *EvaluateOnCallFrameArgs) SetReturnByValue(returnByValue bool) *EvaluateOnCallFrameArgs {
	a.ReturnByValue = &returnByValue
	return a
}
165768
func (f *ScmpFilter) AddRule(call ScmpSyscall, action ScmpAction) error {
	return f.addRuleGeneric(call, action, false, nil)
}