Return slices not pointers

nova/nova.go

 // The nova package provides a way to access the OpenStack Compute APIs.
 // See http://docs.openstack.org/api/openstack-compute/2/content/.
 package nova
 
 import (
         "encoding/base64"
         "fmt"
         "launchpad.net/goose/client"
         goosehttp "launchpad.net/goose/http"
         "net/http"
@@ skipping 45 matching lines @@
 type FlavorDetail struct {
         Name  string
         RAM   int
         VCPUs int
         Disk  int
         Id    string
         Swap  interface{} // Can be an empty string (?!)
 }
 
 // ListFlavorsDetail lists all details for available flavors.
-func (c *Client) ListFlavorsDetail() (*[]FlavorDetail, error) {
+func (c *Client) ListFlavorsDetail() ([]FlavorDetail, error) {
         var resp struct {
                 Flavors []FlavorDetail
         }
         requestData := goosehttp.RequestData{RespValue: &resp}
         err := c.client.SendRequest(client.GET, "compute", apiFlavorsDetail, &requestData,
                 "failed to get list of flavors details")
         if err != nil {
                 return nil, err
         }
-        return &resp.Flavors, nil
+        return resp.Flavors, nil
 }
 
 // ListServers lists IDs, names, and links for all servers.
-func (c *Client) ListServers() (*[]Entity, error) {
+func (c *Client) ListServers() ([]Entity, error) {
         var resp struct {
                 Servers []Entity
         }
         requestData := goosehttp.RequestData{RespValue: &resp, ExpectedStatus: []int{http.StatusOK}}
         err := c.client.SendRequest(client.GET, "compute", apiServers, &requestData,
                 "failed to get list of servers")
         if err != nil {
                 return nil, err
         }
-        return &resp.Servers, nil
+        return resp.Servers, nil
 }
 
 type ServerDetail struct {
         AddressIPv4 string
         AddressIPv6 string
         Created     string
         Flavor      Entity
         HostId      string
         Id          string
         Image       Entity
         Links       []Link
         Name        string
         Progress    int
         Status      string
         TenantId    string `json:"tenant_id"`
         Updated     string
         UserId      string `json:"user_id"`
 }
 
 // ListServersDetail lists all details for available servers.
-func (c *Client) ListServersDetail() (*[]ServerDetail, error) {
+func (c *Client) ListServersDetail() ([]ServerDetail, error) {
         var resp struct {
                 Servers []ServerDetail
         }
         requestData := goosehttp.RequestData{RespValue: &resp}
         err := c.client.SendRequest(client.GET, "compute", apiServersDetail, &requestData,
                 "failed to get list of servers details")
         if err != nil {
                 return nil, err
         }
-        return &resp.Servers, nil
+        return resp.Servers, nil
 }
 
 // GetServer lists details for the specified server.
 func (c *Client) GetServer(serverId string) (*ServerDetail, error) {
         var resp struct {
                 Server ServerDetail
         }
         url := fmt.Sprintf("%s/%s", apiServers, serverId)
         requestData := goosehttp.RequestData{RespValue: &resp}
         err := c.client.SendRequest(client.GET, "compute", url, &requestData,
@@ skipping 61 matching lines @@
 
 type SecurityGroup struct {
         Rules       []SecurityGroupRule
         TenantId    string `json:"tenant_id"`
         Id          int
         Name        string
         Description string
 }
 
 // ListSecurityGroups lists IDs, names, and other details for all security groups.
-func (c *Client) ListSecurityGroups() (*[]SecurityGroup, error) {
+func (c *Client) ListSecurityGroups() ([]SecurityGroup, error) {
         var resp struct {
                 Groups []SecurityGroup `json:"security_groups"`
         }
         requestData := goosehttp.RequestData{RespValue: &resp}
         err := c.client.SendRequest(client.GET, "compute", apiSecurityGroups, &requestData,
                 "failed to list security groups")
         if err != nil {
                 return nil, err
         }
-        return &resp.Groups, nil
+        return resp.Groups, nil
 }
 
 // GetServerSecurityGroups list security groups for a specific server.
-func (c *Client) GetServerSecurityGroups(serverId string) (*[]SecurityGroup, error) {
+func (c *Client) GetServerSecurityGroups(serverId string) ([]SecurityGroup, error) {
 
         var resp struct {
                 Groups []SecurityGroup `json:"security_groups"`
         }
         url := fmt.Sprintf("%s/%s/%s", apiServers, serverId, apiSecurityGroups)
         requestData := goosehttp.RequestData{RespValue: &resp}
         err := c.client.SendRequest(client.GET, "compute", url, &requestData,
                 "failed to list server (%s) security groups", serverId)
         if err != nil {
                 return nil, err
         }
-        return &resp.Groups, nil
+        return resp.Groups, nil
 }
 
 // CreateSecurityGroup creates a new security group.
 func (c *Client) CreateSecurityGroup(name, description string) (*SecurityGroup, error) {
         var req struct {
                 SecurityGroup struct {
                         Name        string `json:"name"`
                         Description string `json:"description"`
                 } `json:"security_group"`
         }
@@ skipping 93 matching lines @@
 
 type FloatingIP struct {
         FixedIP    interface{} `json:"fixed_ip"` // Can be a string or null
         Id         int         `json:"id"`
         InstanceId interface{} `json:"instance_id"` // Can be a string or null
         IP         string      `json:"ip"`
         Pool       string      `json:"pool"`
 }
 
 // ListFloatingIPs lists floating IP addresses associated with the tenant or account.
-func (c *Client) ListFloatingIPs() (*[]FloatingIP, error) {
+func (c *Client) ListFloatingIPs() ([]FloatingIP, error) {
         var resp struct {
                 FloatingIPs []FloatingIP `json:"floating_ips"`
         }
 
         requestData := goosehttp.RequestData{RespValue: &resp}
         err := c.client.SendRequest(client.GET, "compute", apiFloatingIPs, &requestData,
                 "failed to list floating ips")
         if err != nil {
                 return nil, err
         }
-        return &resp.FloatingIPs, nil
+        return resp.FloatingIPs, nil
 }
 
 // GetFloatingIP lists details of the floating IP address associated with specified id.
 func (c *Client) GetFloatingIP(ipId int) (*FloatingIP, error) {
         var resp struct {
                 FloatingIP FloatingIP `json:"floating_ip"`
         }
 
         url := fmt.Sprintf("%s/%d", apiFloatingIPs, ipId)
         requestData := goosehttp.RequestData{RespValue: &resp}
@@ skipping 53 matching lines @@
                 } `json:"removeFloatingIp"`
         }
         req.RemoveFloatingIP.Address = address
 
         url := fmt.Sprintf("%s/%s/action", apiServers, serverId)
         requestData := goosehttp.RequestData{ReqValue: req, ExpectedStatus: []int{http.StatusAccepted}}
         err := c.client.SendRequest(client.POST, "compute", url, &requestData,
                 "failed to remove floating ip %s to server %s", address, serverId)
         return err
 }