// GetAutoPageBreak returns true if automatic pages breaks are enabled, false
// otherwise. This is followed by the triggering limit from the bottom of the
// page. This value applies only if automatic page breaks are enabled.
427158
func (f *Fpdf) GetAutoPageBreak() (auto bool, margin float64) {
	auto = f.autoPageBreak
	margin = f.bMargin
	return
}
1123449
func (s *LimitService) GetApiLimit(p *GetApiLimitParams) (*GetApiLimitResponse, error) {
	resp, err := s.cs.newRequest("getApiLimit", p.toURLValues())
	if err != nil {
		return nil, err
	}

	var r GetApiLimitResponse
	if err := json.Unmarshal(resp, &r); err != nil {
		return nil, err
	}

	return &r, nil
}
1039583
func WithAutoPrint(ctx context.Context, bv bool) context.Context {
	return context.WithValue(ctx, ctxKeyAutoPrint, bv)
}
332536
func (client *Client) GetRunstatusMaintenance(ctx context.Context, maintenance RunstatusMaintenance) (*RunstatusMaintenance, error) {
	if maintenance.URL != "" {
		return client.getRunstatusMaintenance(ctx, maintenance.URL)
	}

	if maintenance.PageURL == "" {
		return nil, fmt.Errorf("empty Page URL for %#v", maintenance)
	}

	page, err := client.getRunstatusPage(ctx, maintenance.PageURL)
	if err != nil {
		return nil, err
	}

	for i := range page.Maintenances {
		m := &page.Maintenances[i]
		if m.Match(maintenance) {
			if err := m.FakeID(); err != nil {
				log.Printf("bad fake ID for %#v, %s", m, err)
			}
			return m, nil
		}
	}

	return nil, fmt.Errorf("%#v not found", maintenance)
}
571118
func HasAutoClip(ctx context.Context) bool {
	_, ok := ctx.Value(ctxKeyAutoClip).(bool)
	return ok
}
1147402
func (s *CreateLayerInput) SetEnableAutoHealing(v bool) *CreateLayerInput {
	s.EnableAutoHealing = &v
	return s
}
626261
func (client *Client) PaginateRunstatusMaintenances(ctx context.Context, page RunstatusPage, callback func(*RunstatusMaintenance, error) bool) { // nolint: dupl
	if page.MaintenancesURL == "" {
		callback(nil, fmt.Errorf("empty Maintenances URL for %#v", page))
		return
	}

	maintenancesURL := page.MaintenancesURL
	for maintenancesURL != "" {
		resp, err := client.runstatusRequest(ctx, maintenancesURL, nil, "GET")
		if err != nil {
			callback(nil, err)
			return
		}

		var ms *RunstatusMaintenanceList
		if err := json.Unmarshal(resp, &ms); err != nil {
			callback(nil, err)
			return
		}

		for i := range ms.Maintenances {
			if err := ms.Maintenances[i].FakeID(); err != nil {
				log.Printf("bad fake ID for %#v, %s", ms.Maintenances[i], err)
			}
			if cont := callback(&ms.Maintenances[i], nil); !cont {
				return
			}
		}

		maintenancesURL = ms.Next
	}
}
660284
func ExtractPaginationLimitedTo(opts ...interface{}) *opt.PaginationLimitedToOption {
	for _, o := range opts {
		if v, ok := o.(*opt.PaginationLimitedToOption); ok {
			return v
		}
	}
	return nil
}
175746
func (s *UpdateLayerInput) SetEnableAutoHealing(v bool) *UpdateLayerInput {
	s.EnableAutoHealing = &v
	return s
}
1068841
func (client *Client) PaginateRunstatusIncidents(ctx context.Context, page RunstatusPage, callback func(*RunstatusIncident, error) bool) {
	if page.IncidentsURL == "" {
		callback(nil, fmt.Errorf("empty Incidents URL for %#v", page))
		return
	}

	incidentsURL := page.IncidentsURL
	for incidentsURL != "" {
		resp, err := client.runstatusRequest(ctx, incidentsURL, nil, "GET")
		if err != nil {
			callback(nil, err)
			return
		}

		var is *RunstatusIncidentList
		if err := json.Unmarshal(resp, &is); err != nil {
			callback(nil, err)
			return
		}

		for i := range is.Incidents {
			if cont := callback(&is.Incidents[i], nil); !cont {
				return
			}
		}

		incidentsURL = is.Next
	}
}
72509
func AutomaticOptions(c *web.C, h http.Handler) http.Handler {
	fn := func(w http.ResponseWriter, r *http.Request) {
		if r.Method == "OPTIONS" {
			w = &autoOptionsProxy{c: c, w: w}
		}

		h.ServeHTTP(w, r)
	}

	return http.HandlerFunc(fn)
}
728132
func (s *HTTPServer) checkACLDisabled(resp http.ResponseWriter, req *http.Request) bool {
	if s.agent.delegate.ACLsEnabled() {
		return false
	}

	resp.WriteHeader(http.StatusUnauthorized)
	fmt.Fprint(resp, "ACL support disabled")
	return true
}
1189669
func AuthStop() {
	if !auth_init {
		if auth_verbose {
			log.Println("AUTH: Not running, can't stop")
		}
		return
	}
	if auth_verbose {
		log.Println("AUTH: Stopping")
	}
	_, err := auth_quit.SendMessageDontwait("QUIT")
	if err != nil && auth_verbose {
		log.Println("AUTH: Stopping: SendMessageDontwait(\"QUIT\"):", err)
	}
	_, err = auth_quit.RecvMessage(0)
	if err != nil && auth_verbose {
		log.Println("AUTH: Stopping: RecvMessage:", err)
	}
	err = auth_quit.Close()
	if err != nil && auth_verbose {
		log.Println("AUTH: Stopping: Close:", err)
	}
	if auth_verbose {
		log.Println("AUTH: Stopped")
	}

	auth_init = false

}
1322261
func (b *BigIP) GetActivationStatus() (*Activation, error) {
	var a Activation
	err, _ := b.getForEntity(&a, uriShared, uriLicensing, uriActivation)
	if err != nil {
		return nil, err
	}
	return &a, nil
}
933172
func (bot *TgBot) DefaultDisableWebpagePreview(b bool) *TgBot {
	bot.DefaultOptions.DisableWebURL = &b
	return bot
}
103945
func (s *SignaturesProtectedBranch) GetEnabled() bool {
	if s == nil || s.Enabled == nil {
		return false
	}
	return *s.Enabled
}
96534
func (r Account_ProofOfConcept) GetAuthenticationUrl(targetPage *string) (resp string, err error) {
	params := []interface{}{
		targetPage,
	}
	err = r.Session.DoRequest("SoftLayer_Account_ProofOfConcept", "getAuthenticationUrl", params, &r.Options, &resp)
	return
}