1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
|
// Package additionalprops provides access to the Example API.
//
// Usage example:
//
// import "google.golang.org/api/additionalprops/v1"
// ...
// additionalpropsService, err := additionalprops.New(oauthHttpClient)
package additionalprops
import (
"bytes"
"encoding/json"
"errors"
"fmt"
"golang.org/x/net/context"
"google.golang.org/api/googleapi"
"io"
"net/http"
"net/url"
"strconv"
"strings"
)
// Always reference these packages, just in case the auto-generated code
// below doesn't.
var _ = bytes.NewBuffer
var _ = strconv.Itoa
var _ = fmt.Sprintf
var _ = json.NewDecoder
var _ = io.Copy
var _ = url.Parse
var _ = googleapi.Version
var _ = errors.New
var _ = strings.Replace
var _ = context.Background
const apiId = "additionalprops:v1"
const apiName = "additionalprops"
const apiVersion = "v1"
const basePath = "https://www.googleapis.com/discovery/v1/apis"
func New(client *http.Client) (*Service, error) {
if client == nil {
return nil, errors.New("client is nil")
}
s := &Service{client: client, BasePath: basePath}
s.Atlas = NewAtlasService(s)
return s, nil
}
type Service struct {
client *http.Client
BasePath string // API endpoint base URL
UserAgent string // optional additional User-Agent fragment
Atlas *AtlasService
}
func (s *Service) userAgent() string {
if s.UserAgent == "" {
return googleapi.UserAgent
}
return googleapi.UserAgent + " " + s.UserAgent
}
func NewAtlasService(s *Service) *AtlasService {
rs := &AtlasService{s: s}
return rs
}
type AtlasService struct {
s *Service
}
type TimeseriesDescriptor struct {
// Labels: The set of key-value pairs that describe this time series,
// including target-specific labels and metric-specific labels.
Labels map[string]string `json:"labels,omitempty"`
// Metric: The name of the metric.
Metric string `json:"metric,omitempty"`
// Project: The project ID to which this time series belongs.
Project string `json:"project,omitempty"`
// Tags: A map of additional information.
Tags map[string][]string `json:"tags,omitempty"`
}
// method id "mapofstrings.getMap":
type AtlasGetMapCall struct {
s *Service
opt_ map[string]interface{}
}
// GetMap: Get a map.
func (r *AtlasService) GetMap() *AtlasGetMapCall {
c := &AtlasGetMapCall{s: r.s, opt_: make(map[string]interface{})}
return c
}
// Fields allows partial responses to be retrieved.
// See https://developers.google.com/gdata/docs/2.0/basics#PartialResponse
// for more information.
func (c *AtlasGetMapCall) Fields(s ...googleapi.Field) *AtlasGetMapCall {
c.opt_["fields"] = googleapi.CombineFields(s)
return c
}
func (c *AtlasGetMapCall) Do() (map[string]string, error) {
var body io.Reader = nil
params := make(url.Values)
params.Set("alt", "json")
if v, ok := c.opt_["fields"]; ok {
params.Set("fields", fmt.Sprintf("%v", v))
}
urls := googleapi.ResolveRelative(c.s.BasePath, "map")
urls += "?" + params.Encode()
req, _ := http.NewRequest("GET", urls, body)
googleapi.SetOpaque(req.URL)
req.Header.Set("User-Agent", c.s.userAgent())
res, err := c.s.client.Do(req)
if err != nil {
return nil, err
}
defer googleapi.CloseBody(res)
if err := googleapi.CheckResponse(res); err != nil {
return nil, err
}
var ret map[string]string
if err := json.NewDecoder(res.Body).Decode(&ret); err != nil {
return nil, err
}
return ret, nil
// {
// "description": "Get a map.",
// "httpMethod": "GET",
// "id": "mapofstrings.getMap",
// "path": "map",
// "response": {
// "$ref": "GetMapResponse"
// }
// }
}
|
