github.com/gophercloud/gophercloud@v1.11.0/openstack/identity/v3/registeredlimits/results.go (about)

     1  package registeredlimits
     2  
     3  import (
     4  	"github.com/gophercloud/gophercloud"
     5  	"github.com/gophercloud/gophercloud/pagination"
     6  )
     7  
     8  // A model describing the configured enforcement model used by the deployment.
     9  type EnforcementModel struct {
    10  	// The name of the enforcement model.
    11  	Name string `json:"name"`
    12  
    13  	// A short description of the enforcement model used.
    14  	Description string `json:"description"`
    15  }
    16  
    17  // EnforcementModelResult is the response from a GetEnforcementModel operation. Call its Extract method
    18  // to interpret it as a EnforcementModel.
    19  type EnforcementModelResult struct {
    20  	gophercloud.Result
    21  }
    22  
    23  // Extract interprets EnforcementModelResult as a EnforcementModel.
    24  func (r EnforcementModelResult) Extract() (*EnforcementModel, error) {
    25  	var out struct {
    26  		Model *EnforcementModel `json:"model"`
    27  	}
    28  	err := r.ExtractInto(&out)
    29  	return out.Model, err
    30  }
    31  
    32  // A registered limit is the limit that is default for all projects.
    33  type RegisteredLimit struct {
    34  	// ID is the unique ID of the limit.
    35  	ID string `json:"id"`
    36  
    37  	// RegionID is the ID of the region where the limit is applied.
    38  	RegionID string `json:"region_id"`
    39  
    40  	// ServiceID is the ID of the service where the limit is applied.
    41  	ServiceID string `json:"service_id"`
    42  
    43  	// Description of the limit.
    44  	Description string `json:"description"`
    45  
    46  	// ResourceName is the name of the resource that the limit is applied to.
    47  	ResourceName string `json:"resource_name"`
    48  
    49  	// DefaultLimit is the default limit.
    50  	DefaultLimit int `json:"default_limit"`
    51  
    52  	// Links contains referencing links to the limit.
    53  	Links map[string]interface{} `json:"links"`
    54  }
    55  
    56  // A LimitsOutput is an array of limits returned by List and BatchCreate operations
    57  type RegisteredLimitsOutput struct {
    58  	RegisteredLimits []RegisteredLimit `json:"registered_limits"`
    59  }
    60  
    61  // A RegisteredLimitOutput is an encapsulated Limit returned by Get and Update operations
    62  type RegisteredLimitOutput struct {
    63  	RegisteredLimit *RegisteredLimit `json:"registered_limit"`
    64  }
    65  
    66  // RegisteredLimitPage is a single page of Registered Limit results.
    67  type RegisteredLimitPage struct {
    68  	pagination.LinkedPageBase
    69  }
    70  
    71  type commonResult struct {
    72  	gophercloud.Result
    73  }
    74  
    75  // GetResult is the response from a Get operation. Call its Extract method
    76  // to interpret it as a RegisteredLimit.
    77  type GetResult struct {
    78  	commonResult
    79  }
    80  
    81  // CreateResult is the response from a Create operation. Call its Extract method
    82  // to interpret it as a Registered Limits.
    83  type CreateResult struct {
    84  	gophercloud.Result
    85  }
    86  
    87  // UpdateResult is the result of an Update request. Call its Extract method to
    88  // interpret it as a Limit.
    89  type UpdateResult struct {
    90  	commonResult
    91  }
    92  
    93  // DeleteResult is the result of a Delete request. Call its ExtractErr method to
    94  // determine if the request succeeded or failed.
    95  type DeleteResult struct {
    96  	gophercloud.ErrResult
    97  }
    98  
    99  // IsEmpty determines whether or not a page of Limits contains any results.
   100  func (r RegisteredLimitPage) IsEmpty() (bool, error) {
   101  	if r.StatusCode == 204 {
   102  		return true, nil
   103  	}
   104  
   105  	registered_limits, err := ExtractRegisteredLimits(r)
   106  	return len(registered_limits) == 0, err
   107  }
   108  
   109  // NextPageURL extracts the "next" link from the links section of the result.
   110  func (r RegisteredLimitPage) NextPageURL() (string, error) {
   111  	var s struct {
   112  		Links struct {
   113  			Next     string `json:"next"`
   114  			Previous string `json:"previous"`
   115  		} `json:"links"`
   116  	}
   117  	err := r.ExtractInto(&s)
   118  	if err != nil {
   119  		return "", err
   120  	}
   121  	return s.Links.Next, err
   122  }
   123  
   124  // ExtractRegisteredLimits returns a slice of Registered Limits contained in a single page of
   125  // results.
   126  func ExtractRegisteredLimits(r pagination.Page) ([]RegisteredLimit, error) {
   127  	var out RegisteredLimitsOutput
   128  	err := (r.(RegisteredLimitPage)).ExtractInto(&out)
   129  	return out.RegisteredLimits, err
   130  }
   131  
   132  // Extract interprets CreateResult as slice of RegisteredLimits.
   133  func (r CreateResult) Extract() ([]RegisteredLimit, error) {
   134  	var out RegisteredLimitsOutput
   135  	err := r.ExtractInto(&out)
   136  	return out.RegisteredLimits, err
   137  }
   138  
   139  // Extract interprets any commonResult as a RegisteredLimit.
   140  func (r commonResult) Extract() (*RegisteredLimit, error) {
   141  	var out RegisteredLimitOutput
   142  	err := r.ExtractInto(&out)
   143  	return out.RegisteredLimit, err
   144  }