_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3 values | text stringlengths 52 85.5k | language stringclasses 1 value | meta_information dict |
|---|---|---|---|---|---|
q17300 | ListAppEventsByQuery | train | func (c *Client) ListAppEventsByQuery(eventType string, queries []AppEventQuery) ([]AppEventEntity, error) {
var events []AppEventEntity
if eventType != AppCrash && eventType != AppStart && eventType != AppStop && eventType != AppUpdate && eventType != AppCreate &&
eventType != AppDelete && eventType != AppSSHAuth && eventType != AppSSHUnauth && eventType != AppRestage &&
eventType != AppMapRoute && eventType != AppUnmapRoute {
return nil, errors.New("Unsupported app event type " + eventType)
}
var query = "/v2/events?q=type:" + eventType
//adding the additional queries
if queries != nil && len(queries) > 0 {
for _, eventQuery := range queries {
if eventQuery.Filter != FilterTimestamp && eventQuery.Filter != FilterActee {
return nil, errors.New("Unsupported query filter type " + eventQuery.Filter)
}
if !stringInSlice(eventQuery.Operator, ValidOperators) {
return nil, errors.New("Unsupported query operator type " + eventQuery.Operator)
}
query += "&q=" + eventQuery.Filter + eventQuery.Operator + eventQuery.Value
}
}
for {
eventResponse, err := c.getAppEventsResponse(query)
if err != nil {
return []AppEventEntity{}, err
}
for _, event := range eventResponse.Resources {
events = append(events, event.Entity)
}
query = eventResponse.NextURL
if query == "" {
break
}
}
return events, nil
} | go | {
"resource": ""
} |
q17301 | CreateServiceKey | train | func (c *Client) CreateServiceKey(csr CreateServiceKeyRequest) (ServiceKey, error) {
var serviceKeyResource ServiceKeyResource
buf := bytes.NewBuffer(nil)
err := json.NewEncoder(buf).Encode(csr)
if err != nil {
return ServiceKey{}, err
}
req := c.NewRequestWithBody("POST", "/v2/service_keys", buf)
resp, err := c.DoRequest(req)
if err != nil {
return ServiceKey{}, err
}
if resp.StatusCode != http.StatusCreated {
return ServiceKey{}, fmt.Errorf("CF API returned with status code %d", resp.StatusCode)
}
body, err := ioutil.ReadAll(resp.Body)
defer resp.Body.Close()
if err != nil {
return ServiceKey{}, err
}
err = json.Unmarshal(body, &serviceKeyResource)
if err != nil {
return ServiceKey{}, err
}
return serviceKeyResource.Entity, nil
} | go | {
"resource": ""
} |
q17302 | respBodyToSecGroup | train | func respBodyToSecGroup(body io.ReadCloser, c *Client) (*SecGroup, error) {
//get the json from the response body
bodyRaw, err := ioutil.ReadAll(body)
if err != nil {
return nil, errors.Wrap(err, "Could not read response body")
}
jStruct := SecGroupResource{}
//make it a SecGroup
err = json.Unmarshal(bodyRaw, &jStruct)
if err != nil {
return nil, errors.Wrap(err, "Could not unmarshal response body as json")
}
//pull a few extra fields from other places
ret := jStruct.Entity
ret.Guid = jStruct.Meta.Guid
ret.CreatedAt = jStruct.Meta.CreatedAt
ret.UpdatedAt = jStruct.Meta.UpdatedAt
ret.c = c
return &ret, nil
} | go | {
"resource": ""
} |
q17303 | secGroupCreateHelper | train | func (c *Client) secGroupCreateHelper(url, method, name string, rules []SecGroupRule, spaceGuids []string) (*SecGroup, error) {
reqRules := make([]map[string]interface{}, len(rules))
for i, rule := range rules {
reqRules[i] = convertStructToMap(rule)
protocol := strings.ToLower(reqRules[i]["protocol"].(string))
// if not icmp protocol need to remove the Code/Type fields
if protocol != "icmp" {
delete(reqRules[i], "code")
delete(reqRules[i], "type")
}
}
req := c.NewRequest(method, url)
//set up request body
inputs := map[string]interface{}{
"name": name,
"rules": reqRules,
}
if spaceGuids != nil {
inputs["space_guids"] = spaceGuids
}
req.obj = inputs
//fire off the request and check for problems
resp, err := c.DoRequest(req)
if err != nil {
return nil, err
}
if resp.StatusCode != 201 { // Both create and update should give 201 CREATED
var response SecGroupCreateResponse
bodyRaw, _ := ioutil.ReadAll(resp.Body)
err = json.Unmarshal(bodyRaw, &response)
if err != nil {
return nil, errors.Wrap(err, "Error unmarshaling response")
}
return nil, fmt.Errorf(`Request failed CF API returned with status code %d
-------------------------------
Error Code %s
Code %d
Description %s`,
resp.StatusCode, response.ErrorCode, response.Code, response.Description)
}
//get the json from the response body
return respBodyToSecGroup(resp.Body, c)
} | go | {
"resource": ""
} |
q17304 | ListAllProcessesByQuery | train | func (c *Client) ListAllProcessesByQuery(query url.Values) ([]Process, error) {
var allProcesses []Process
urlPath := "/v3/processes"
for {
resp, err := c.getProcessPage(urlPath, query)
if err != nil {
return nil, err
}
if resp.Pagination.TotalResults == 0 {
return nil, nil
}
if allProcesses == nil {
allProcesses = make([]Process, 0, resp.Pagination.TotalResults)
}
allProcesses = append(allProcesses, resp.Processes...)
if resp.Pagination.Next == nil {
return allProcesses, nil
}
var nextURL string
if resp.Pagination.Next == nil {
return allProcesses, nil
}
switch resp.Pagination.Next.(type) {
case string:
nextURL = resp.Pagination.Next.(string)
case map[string]interface{}:
m := resp.Pagination.Next.(map[string]interface{})
u, ok := m["href"]
if ok {
nextURL = u.(string)
}
default:
return nil, fmt.Errorf("Unexpected type [%s] for next url", reflect.TypeOf(resp.Pagination.Next).String())
}
if nextURL == "" {
return allProcesses, nil
}
u, err := url.Parse(nextURL)
if err != nil {
return nil, err
}
urlPath = u.Path
query, err = url.ParseQuery(u.RawQuery)
if err != nil {
return nil, err
}
}
} | go | {
"resource": ""
} |
q17305 | ListAppsByQueryWithLimits | train | func (c *Client) ListAppsByQueryWithLimits(query url.Values, totalPages int) ([]App, error) {
return c.listApps("/v2/apps?"+query.Encode(), totalPages)
} | go | {
"resource": ""
} |
q17306 | GetAppByGuidNoInlineCall | train | func (c *Client) GetAppByGuidNoInlineCall(guid string) (App, error) {
var appResource AppResource
r := c.NewRequest("GET", "/v2/apps/"+guid)
resp, err := c.DoRequest(r)
if err != nil {
return App{}, errors.Wrap(err, "Error requesting apps")
}
defer resp.Body.Close()
resBody, err := ioutil.ReadAll(resp.Body)
if err != nil {
return App{}, errors.Wrap(err, "Error reading app response body")
}
err = json.Unmarshal(resBody, &appResource)
if err != nil {
return App{}, errors.Wrap(err, "Error unmarshalling app")
}
app := c.mergeAppResource(appResource)
// If no Space Information no need to check org.
if app.SpaceGuid != "" {
//Getting Spaces Resource
space, err := app.Space()
if err != nil {
errors.Wrap(err, "Unable to get the Space for the apps "+app.Name)
} else {
app.SpaceData.Entity = space
}
//Getting orgResource
org, err := app.SpaceData.Entity.Org()
if err != nil {
errors.Wrap(err, "Unable to get the Org for the apps "+app.Name)
} else {
app.SpaceData.Entity.OrgData.Entity = org
}
}
return app, nil
} | go | {
"resource": ""
} |
q17307 | AppByName | train | func (c *Client) AppByName(appName, spaceGuid, orgGuid string) (app App, err error) {
query := url.Values{}
query.Add("q", fmt.Sprintf("organization_guid:%s", orgGuid))
query.Add("q", fmt.Sprintf("space_guid:%s", spaceGuid))
query.Add("q", fmt.Sprintf("name:%s", appName))
apps, err := c.ListAppsByQuery(query)
if err != nil {
return
}
if len(apps) == 0 {
err = fmt.Errorf("No app found with name: `%s` in space with GUID `%s` and org with GUID `%s`", appName, spaceGuid, orgGuid)
return
}
app = apps[0]
return
} | go | {
"resource": ""
} |
q17308 | UploadAppBits | train | func (c *Client) UploadAppBits(file io.Reader, appGUID string) error {
requestFile, err := ioutil.TempFile("", "requests")
defer func() {
requestFile.Close()
os.Remove(requestFile.Name())
}()
writer := multipart.NewWriter(requestFile)
err = writer.WriteField("resources", "[]")
if err != nil {
return errors.Wrapf(err, "Error uploading app %s bits", appGUID)
}
part, err := writer.CreateFormFile("application", "application.zip")
if err != nil {
return errors.Wrapf(err, "Error uploading app %s bits", appGUID)
}
_, err = io.Copy(part, file)
if err != nil {
return errors.Wrapf(err, "Error uploading app %s bits, failed to copy all bytes", appGUID)
}
err = writer.Close()
if err != nil {
return errors.Wrapf(err, "Error uploading app %s bits, failed to close multipart writer", appGUID)
}
requestFile.Seek(0, 0)
fileStats, err := requestFile.Stat()
if err != nil {
return errors.Wrapf(err, "Error uploading app %s bits, failed to get temp file stats", appGUID)
}
requestURL := fmt.Sprintf("/v2/apps/%s/bits", appGUID)
r := c.NewRequestWithBody("PUT", requestURL, requestFile)
req, err := r.toHTTP()
if err != nil {
return errors.Wrapf(err, "Error uploading app %s bits", appGUID)
}
req.ContentLength = fileStats.Size()
contentType := fmt.Sprintf("multipart/form-data; boundary=%s", writer.Boundary())
req.Header.Set("Content-Type", contentType)
resp, err := c.Do(req)
if err != nil {
return errors.Wrapf(err, "Error uploading app %s bits", appGUID)
}
if resp.StatusCode != http.StatusCreated {
return errors.Wrapf(err, "Error uploading app %s bits, response code: %d", appGUID, resp.StatusCode)
}
return nil
} | go | {
"resource": ""
} |
q17309 | GetAppBits | train | func (c *Client) GetAppBits(guid string) (io.ReadCloser, error) {
requestURL := fmt.Sprintf("/v2/apps/%s/download", guid)
req := c.NewRequest("GET", requestURL)
resp, err := c.DoRequestWithoutRedirects(req)
if err != nil {
return nil, errors.Wrapf(err, "Error downloading app %s bits, API request failed", guid)
}
if isResponseRedirect(resp) {
// directly download the bits from blobstore using a non cloud controller transport
// some blobstores will return a 400 if an Authorization header is sent
blobStoreLocation := resp.Header.Get("Location")
tr := &http.Transport{
TLSClientConfig: &tls.Config{InsecureSkipVerify: c.Config.SkipSslValidation},
}
client := &http.Client{Transport: tr}
resp, err = client.Get(blobStoreLocation)
if err != nil {
return nil, errors.Wrapf(err, "Error downloading app %s bits from blobstore", guid)
}
} else {
return nil, errors.Wrapf(err, "Error downloading app %s bits, expected redirect to blobstore", guid)
}
return resp.Body, nil
} | go | {
"resource": ""
} |
q17310 | CreateApp | train | func (c *Client) CreateApp(req AppCreateRequest) (App, error) {
var appResp AppResource
buf := bytes.NewBuffer(nil)
err := json.NewEncoder(buf).Encode(req)
if err != nil {
return App{}, err
}
r := c.NewRequestWithBody("POST", "/v2/apps", buf)
resp, err := c.DoRequest(r)
if err != nil {
return App{}, errors.Wrapf(err, "Error creating app %s", req.Name)
}
if resp.StatusCode != http.StatusCreated {
return App{}, errors.Wrapf(err, "Error creating app %s, response code: %d", req.Name, resp.StatusCode)
}
resBody, err := ioutil.ReadAll(resp.Body)
defer resp.Body.Close()
if err != nil {
return App{}, errors.Wrapf(err, "Error reading app %s http response body", req.Name)
}
err = json.Unmarshal(resBody, &appResp)
if err != nil {
return App{}, errors.Wrapf(err, "Error deserializing app %s response", req.Name)
}
return c.mergeAppResource(appResp), nil
} | go | {
"resource": ""
} |
q17311 | GetInfo | train | func (c *Client) GetInfo() (*Info, error) {
r := c.NewRequest("GET", "/v2/info")
resp, err := c.DoRequest(r)
if err != nil {
return nil, errors.Wrap(err, "Error requesting info")
}
defer resp.Body.Close()
var i Info
err = json.NewDecoder(resp.Body).Decode(&i)
if err != nil {
return nil, errors.Wrap(err, "Error unmarshalling info")
}
return &i, nil
} | go | {
"resource": ""
} |
q17312 | NewCloudFoundryErrorFromV3Errors | train | func NewCloudFoundryErrorFromV3Errors(cfErrorsV3 CloudFoundryErrorsV3) CloudFoundryError {
if len(cfErrorsV3.Errors) == 0 {
return CloudFoundryError{
0,
"GO-Client-No-Errors",
"No Errors in response from V3",
}
}
return CloudFoundryError{
cfErrorsV3.Errors[0].Code,
cfErrorsV3.Errors[0].Title,
cfErrorsV3.Errors[0].Detail,
}
} | go | {
"resource": ""
} |
q17313 | ListServiceUsageEventsByQuery | train | func (c *Client) ListServiceUsageEventsByQuery(query url.Values) ([]ServiceUsageEvent, error) {
var serviceUsageEvents []ServiceUsageEvent
requestURL := fmt.Sprintf("/v2/service_usage_events?%s", query.Encode())
for {
var serviceUsageEventsResponse ServiceUsageEventsResponse
r := c.NewRequest("GET", requestURL)
resp, err := c.DoRequest(r)
if err != nil {
return nil, errors.Wrap(err, "error requesting events")
}
defer resp.Body.Close()
if err := json.NewDecoder(resp.Body).Decode(&serviceUsageEventsResponse); err != nil {
return nil, errors.Wrap(err, "error unmarshaling events")
}
for _, e := range serviceUsageEventsResponse.Resources {
e.Entity.GUID = e.Meta.Guid
e.Entity.CreatedAt = e.Meta.CreatedAt
e.Entity.c = c
serviceUsageEvents = append(serviceUsageEvents, e.Entity)
}
requestURL = serviceUsageEventsResponse.NextURL
if requestURL == "" {
break
}
}
return serviceUsageEvents, nil
} | go | {
"resource": ""
} |
q17314 | ListEventsByQuery | train | func (c *Client) ListEventsByQuery(query url.Values) ([]Event, error) {
var events []Event
requestURL := fmt.Sprintf("/v2/events?%s", query.Encode())
for {
var eventResp EventsResponse
r := c.NewRequest("GET", requestURL)
resp, err := c.DoRequest(r)
if err != nil {
return nil, errors.Wrap(err, "error requesting events")
}
defer resp.Body.Close()
if err := json.NewDecoder(resp.Body).Decode(&eventResp); err != nil {
return nil, errors.Wrap(err, "error unmarshaling events")
}
for _, e := range eventResp.Resources {
e.Entity.GUID = e.Meta.Guid
e.Entity.CreatedAt = e.Meta.CreatedAt
e.Entity.c = c
events = append(events, e.Entity)
}
requestURL = eventResp.NextURL
if requestURL == "" {
break
}
}
return events, nil
} | go | {
"resource": ""
} |
q17315 | TotalEventsByQuery | train | func (c *Client) TotalEventsByQuery(query url.Values) (int, error) {
r := c.NewRequest("GET", fmt.Sprintf("/v2/events?%s", query.Encode()))
resp, err := c.DoRequest(r)
if err != nil {
return 0, errors.Wrap(err, "error requesting events")
}
defer resp.Body.Close()
var apiResp EventsResponse
if err := json.NewDecoder(resp.Body).Decode(&apiResp); err != nil {
return 0, errors.Wrap(err, "error unmarshaling events")
}
return apiResp.TotalResults, nil
} | go | {
"resource": ""
} |
q17316 | CreateTask | train | func (c *Client) CreateTask(tr TaskRequest) (task Task, err error) {
bodyReader, err := createReader(tr)
if err != nil {
return task, err
}
request := fmt.Sprintf("/v3/apps/%s/tasks", tr.DropletGUID)
req := c.NewRequestWithBody("POST", request, bodyReader)
resp, err := c.DoRequest(req)
if err != nil {
return task, errors.Wrap(err, "Error creating task")
}
defer resp.Body.Close()
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
return task, errors.Wrap(err, "Error reading task after creation")
}
err = json.Unmarshal(body, &task)
if err != nil {
return task, errors.Wrap(err, "Error unmarshaling task")
}
return task, err
} | go | {
"resource": ""
} |
q17317 | GetTaskByGuid | train | func (c *Client) GetTaskByGuid(guid string) (task Task, err error) {
request := fmt.Sprintf("/v3/tasks/%s", guid)
req := c.NewRequest("GET", request)
resp, err := c.DoRequest(req)
if err != nil {
return task, errors.Wrap(err, "Error requesting task")
}
defer resp.Body.Close()
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
return task, errors.Wrap(err, "Error reading task")
}
err = json.Unmarshal(body, &task)
if err != nil {
return task, errors.Wrap(err, "Error unmarshaling task")
}
return task, err
} | go | {
"resource": ""
} |
q17318 | TerminateTask | train | func (c *Client) TerminateTask(guid string) error {
req := c.NewRequest("PUT", fmt.Sprintf("/v3/tasks/%s/cancel", guid))
resp, err := c.DoRequest(req)
if err != nil {
return errors.Wrap(err, "Error terminating task")
}
defer resp.Body.Close()
if resp.StatusCode != 202 {
return errors.Wrapf(err, "Failed terminating task, response status code %d", resp.StatusCode)
}
return nil
} | go | {
"resource": ""
} |
q17319 | DefaultConfig | train | func DefaultConfig() *Config {
return &Config{
ApiAddress: "http://api.bosh-lite.com",
Username: "admin",
Password: "admin",
Token: "",
SkipSslValidation: false,
HttpClient: http.DefaultClient,
UserAgent: "Go-CF-client/1.1",
}
} | go | {
"resource": ""
} |
q17320 | getUserTokenAuth | train | func getUserTokenAuth(ctx context.Context, config Config, endpoint *Endpoint) Config {
authConfig := &oauth2.Config{
ClientID: "cf",
Scopes: []string{""},
Endpoint: oauth2.Endpoint{
AuthURL: endpoint.AuthEndpoint + "/oauth/auth",
TokenURL: endpoint.TokenEndpoint + "/oauth/token",
},
}
// Token is expected to have no "bearer" prefix
token := &oauth2.Token{
AccessToken: config.Token,
TokenType: "Bearer"}
config.TokenSource = authConfig.TokenSource(ctx, token)
config.HttpClient = oauth2.NewClient(ctx, config.TokenSource)
return config
} | go | {
"resource": ""
} |
q17321 | NewRequest | train | func (c *Client) NewRequest(method, path string) *Request {
r := &Request{
method: method,
url: c.Config.ApiAddress + path,
params: make(map[string][]string),
}
return r
} | go | {
"resource": ""
} |
q17322 | NewRequestWithBody | train | func (c *Client) NewRequestWithBody(method, path string, body io.Reader) *Request {
r := c.NewRequest(method, path)
// Set request body
r.body = body
return r
} | go | {
"resource": ""
} |
q17323 | DoRequestWithoutRedirects | train | func (c *Client) DoRequestWithoutRedirects(r *Request) (*http.Response, error) {
prevCheckRedirect := c.Config.HttpClient.CheckRedirect
c.Config.HttpClient.CheckRedirect = func(httpReq *http.Request, via []*http.Request) error {
return http.ErrUseLastResponse
}
defer func() {
c.Config.HttpClient.CheckRedirect = prevCheckRedirect
}()
return c.DoRequest(r)
} | go | {
"resource": ""
} |
q17324 | CreateServicePlanVisibilityByUniqueId | train | func (c *Client) CreateServicePlanVisibilityByUniqueId(uniqueId string, organizationGuid string) (ServicePlanVisibility, error) {
q := url.Values{}
q.Set("q", fmt.Sprintf("unique_id:%s", uniqueId))
plans, err := c.ListServicePlansByQuery(q)
if err != nil {
return ServicePlanVisibility{}, errors.Wrap(err, fmt.Sprintf("Couldn't find a service plan with unique_id: %s", uniqueId))
}
return c.CreateServicePlanVisibility(plans[0].Guid, organizationGuid)
} | go | {
"resource": ""
} |
q17325 | GetUserByGUID | train | func (c *Client) GetUserByGUID(guid string) (User, error) {
var userRes UserResource
r := c.NewRequest("GET", "/v2/users/"+guid)
resp, err := c.DoRequest(r)
if err != nil {
return User{}, err
}
body, err := ioutil.ReadAll(resp.Body)
defer resp.Body.Close()
if err != nil {
return User{}, err
}
err = json.Unmarshal(body, &userRes)
if err != nil {
return User{}, err
}
return c.mergeUserResource(userRes), nil
} | go | {
"resource": ""
} |
q17326 | ListAppUsageEventsByQuery | train | func (c *Client) ListAppUsageEventsByQuery(query url.Values) ([]AppUsageEvent, error) {
var appUsageEvents []AppUsageEvent
requestURL := fmt.Sprintf("/v2/app_usage_events?%s", query.Encode())
for {
var appUsageEventsResponse AppUsageEventsResponse
r := c.NewRequest("GET", requestURL)
resp, err := c.DoRequest(r)
if err != nil {
return nil, errors.Wrap(err, "error requesting events")
}
defer resp.Body.Close()
if err := json.NewDecoder(resp.Body).Decode(&appUsageEventsResponse); err != nil {
return nil, errors.Wrap(err, "error unmarshaling events")
}
for _, e := range appUsageEventsResponse.Resources {
e.Entity.GUID = e.Meta.Guid
e.Entity.CreatedAt = e.Meta.CreatedAt
e.Entity.c = c
appUsageEvents = append(appUsageEvents, e.Entity)
}
requestURL = appUsageEventsResponse.NextURL
if requestURL == "" {
break
}
}
return appUsageEvents, nil
} | go | {
"resource": ""
} |
q17327 | CreateRoute | train | func (c *Client) CreateRoute(routeRequest RouteRequest) (Route, error) {
routesResource, err := c.createRoute("/v2/routes", routeRequest)
if nil != err {
return Route{}, err
}
return c.mergeRouteResource(routesResource), nil
} | go | {
"resource": ""
} |
q17328 | BindRoute | train | func (c *Client) BindRoute(routeGUID, appGUID string) error {
resp, err := c.DoRequest(c.NewRequest("PUT", fmt.Sprintf("/v2/routes/%s/apps/%s", routeGUID, appGUID)))
if err != nil {
return errors.Wrapf(err, "Error binding route %s to app %s", routeGUID, appGUID)
}
if resp.StatusCode != http.StatusCreated {
return fmt.Errorf("Error binding route %s to app %s, response code: %d", routeGUID, appGUID, resp.StatusCode)
}
return nil
} | go | {
"resource": ""
} |
q17329 | Check | train | func (d *Descriptor) Check() error {
if d.Pack < 1 || d.Pack > 4 {
return fmt.Errorf("invalid pack value %v", d.Pack)
}
for i := 0; i < d.Planes; i++ {
h := d.GetHeight(i)
if d.Interlaced && h%2 != 0 && h != d.Height {
return fmt.Errorf("invalid interlaced input height %v", d.Height)
}
}
return nil
} | go | {
"resource": ""
} |
q17330 | GetWidth | train | func (d *Descriptor) GetWidth(plane int) int {
if plane < 0 || plane+1 > maxPlanes {
panic(fmt.Errorf("invalid plane %v", plane))
}
if plane == 0 {
return d.Width
}
switch d.Ratio {
case Ratio410, Ratio411:
return (d.Width + 3) >> 2
case Ratio420, Ratio422:
return (d.Width + 1) >> 1
case Ratio440, Ratio444:
return d.Width
}
panic(fmt.Errorf("invalid ratio %v", d.Ratio))
} | go | {
"resource": ""
} |
q17331 | GetHeight | train | func (d *Descriptor) GetHeight(plane int) int {
if plane < 0 || plane+1 > maxPlanes {
panic(fmt.Errorf("invalid plane %v", plane))
}
if plane == 0 {
return d.Height
}
switch d.Ratio {
case Ratio411, Ratio422, Ratio444:
return d.Height
case Ratio410, Ratio420, Ratio440:
h := (d.Height + 1) >> 1
if d.Interlaced && h&1 != 0 {
h++
}
return h
}
panic(fmt.Errorf("invalid ratio %v", d.Ratio))
} | go | {
"resource": ""
} |
q17332 | GetRatio | train | func GetRatio(value image.YCbCrSubsampleRatio) ChromaRatio {
switch value {
case image.YCbCrSubsampleRatio410:
return Ratio410
case image.YCbCrSubsampleRatio411:
return Ratio411
case image.YCbCrSubsampleRatio420:
return Ratio420
case image.YCbCrSubsampleRatio422:
return Ratio422
case image.YCbCrSubsampleRatio440:
return Ratio440
case image.YCbCrSubsampleRatio444:
return Ratio444
}
return Ratio444
} | go | {
"resource": ""
} |
q17333 | PrepareConversion | train | func PrepareConversion(output, input image.Image) (*ConverterConfig, error) {
src, _, err := inspect(input, false)
if err != nil {
return nil, err
}
dst, _, err := inspect(output, false)
if err != nil {
return nil, err
}
err = checkConversion(dst, src)
if err != nil {
return nil, err
}
return &ConverterConfig{
Input: *src,
Output: *dst,
}, nil
} | go | {
"resource": ""
} |
q17334 | Psnr | train | func Psnr(a, b image.Image) ([]float64, error) {
psnrs := []float64{}
id, src, err := inspect(a, false)
if err != nil {
return nil, err
}
od, dst, err := inspect(b, false)
if err != nil {
return nil, err
}
if *id != *od {
return nil, fmt.Errorf("unable to psnr different formats")
}
for i := 0; i < len(dst); i++ {
psnrs = append(psnrs, psnrPlane(src[i].Data, dst[i].Data, src[i].Width*src[i].Pack, src[i].Height, src[i].Pitch, dst[i].Pitch))
}
return psnrs, nil
} | go | {
"resource": ""
} |
q17335 | NewResize | train | func NewResize(cfg *ResizerConfig, filter Filter) Resizer {
ctx := context{
cfg: *cfg,
}
ctx.cfg.Depth = 8 // only 8-bit for now
if ctx.cfg.Pack < 1 {
ctx.cfg.Pack = 1
}
ctx.kernels = []kernel{makeKernel(&ctx.cfg, filter, 0)}
ctx.scaler = getHorizontalScaler(ctx.kernels[0].size, !cfg.DisableAsm)
if cfg.Vertical {
ctx.scaler = getVerticalScaler(ctx.kernels[0].size, !cfg.DisableAsm)
if cfg.Interlaced {
ctx.kernels = append(ctx.kernels, makeKernel(&ctx.cfg, filter, 1))
}
}
return &ctx
} | go | {
"resource": ""
} |
q17336 | h8scale2Go | train | func h8scale2Go(dst, src []byte, cof, off []int16,
taps, width, height, dp, sp int) {
di := 0
si := 0
for y := 0; y < height; y++ {
c := cof
s := src[si:]
d := dst[di:]
for x, xoff := range off[:width] {
pix := int(s[xoff+0])*int(c[0]) +
int(s[xoff+1])*int(c[1])
d[x] = u8((pix + 1<<(Bits-1)) >> Bits)
c = c[2:]
}
di += dp
si += sp
}
} | go | {
"resource": ""
} |
q17337 | DumpImage | train | func DumpImage(prefix string, img image.Image) error {
_, src, err := inspect(img, false)
if err != nil {
return err
}
for i, p := range src {
err = dumpPlane(prefix, &p, i)
if err != nil {
return err
}
}
return nil
} | go | {
"resource": ""
} |
q17338 | NewListFromString | train | func NewListFromString(src string, options *ParserOption) (*List, error) {
l := NewList()
_, err := l.LoadString(src, options)
return l, err
} | go | {
"resource": ""
} |
q17339 | NewListFromFile | train | func NewListFromFile(path string, options *ParserOption) (*List, error) {
l := NewList()
_, err := l.LoadFile(path, options)
return l, err
} | go | {
"resource": ""
} |
q17340 | Load | train | func (l *List) Load(r io.Reader, options *ParserOption) ([]Rule, error) {
return l.parse(r, options)
} | go | {
"resource": ""
} |
q17341 | LoadString | train | func (l *List) LoadString(src string, options *ParserOption) ([]Rule, error) {
r := strings.NewReader(src)
return l.parse(r, options)
} | go | {
"resource": ""
} |
q17342 | LoadFile | train | func (l *List) LoadFile(path string, options *ParserOption) ([]Rule, error) {
f, err := os.Open(path)
if err != nil {
return nil, err
}
defer f.Close()
return l.parse(f, options)
} | go | {
"resource": ""
} |
q17343 | AddRule | train | func (l *List) AddRule(r *Rule) error {
l.rules[r.Value] = r
return nil
} | go | {
"resource": ""
} |
q17344 | Find | train | func (l *List) Find(name string, options *FindOptions) *Rule {
if options == nil {
options = DefaultFindOptions
}
part := name
for {
rule, ok := l.rules[part]
if ok && rule.Match(name) && !(options.IgnorePrivate && rule.Private) {
return rule
}
i := strings.IndexRune(part, '.')
if i < 0 {
return options.DefaultRule
}
part = part[i+1:]
}
return nil
} | go | {
"resource": ""
} |
q17345 | MustNewRule | train | func MustNewRule(content string) *Rule {
rule, err := NewRule(content)
if err != nil {
panic(err)
}
return rule
} | go | {
"resource": ""
} |
q17346 | PublicSuffix | train | func (l cookiejarList) PublicSuffix(domain string) string {
rule := l.List.Find(domain, nil)
return rule.Decompose(domain)[1]
} | go | {
"resource": ""
} |
q17347 | Visit | train | func (node *Node) Visit(opts *Options) (dirs, files int) {
// visited paths
if path, err := filepath.Abs(node.path); err == nil {
path = filepath.Clean(path)
node.vpaths[path] = true
}
// stat
fi, err := opts.Fs.Stat(node.path)
if err != nil {
node.err = err
return
}
node.FileInfo = fi
if !fi.IsDir() {
return 0, 1
}
// increase dirs only if it's a dir, but not the root.
if node.depth != 0 {
dirs++
}
// DeepLevel option
if opts.DeepLevel > 0 && opts.DeepLevel <= node.depth {
return
}
names, err := opts.Fs.ReadDir(node.path)
if err != nil {
node.err = err
return
}
node.nodes = make(Nodes, 0)
for _, name := range names {
// "all" option
if !opts.All && strings.HasPrefix(name, ".") {
continue
}
nnode := &Node{
path: filepath.Join(node.path, name),
depth: node.depth + 1,
vpaths: node.vpaths,
}
d, f := nnode.Visit(opts)
if nnode.err == nil && !nnode.IsDir() {
// "dirs only" option
if opts.DirsOnly {
continue
}
var rePrefix string
if opts.IgnoreCase {
rePrefix = "(?i)"
}
// Pattern matching
if opts.Pattern != "" {
re, err := regexp.Compile(rePrefix + opts.Pattern)
if err == nil && !re.MatchString(name) {
continue
}
}
// IPattern matching
if opts.IPattern != "" {
re, err := regexp.Compile(rePrefix + opts.IPattern)
if err == nil && re.MatchString(name) {
continue
}
}
}
node.nodes = append(node.nodes, nnode)
dirs, files = dirs+d, files+f
}
// Sorting
if !opts.NoSort {
node.sort(opts)
}
return
} | go | {
"resource": ""
} |
q17348 | formatBytes | train | func formatBytes(i int64) (result string) {
var n float64
sFmt, eFmt := "%.01f", ""
switch {
case i > EB:
eFmt = "E"
n = float64(i) / float64(EB)
case i > PB:
eFmt = "P"
n = float64(i) / float64(PB)
case i > TB:
eFmt = "T"
n = float64(i) / float64(TB)
case i > GB:
eFmt = "G"
n = float64(i) / float64(GB)
case i > MB:
eFmt = "M"
n = float64(i) / float64(MB)
case i > KB:
eFmt = "K"
n = float64(i) / float64(KB)
default:
sFmt = "%.0f"
n = float64(i)
}
if eFmt != "" && n >= 10 {
sFmt = "%.0f"
}
result = fmt.Sprintf(sFmt+eFmt, n)
result = strings.Trim(result, " ")
return
} | go | {
"resource": ""
} |
q17349 | contains | train | func contains(slice []string, str string) bool {
for _, val := range slice {
if val == strings.ToLower(str) {
return true
}
}
return false
} | go | {
"resource": ""
} |
q17350 | getIdentityFieldNameFromStruct | train | func getIdentityFieldNameFromStruct(instance interface{}, fallbackIdentityFieldName string) (string, string, error) {
if err := validatePtrToStructType(instance); err != nil {
return ``, ``, err
}
s := structs.New(instance)
// find a field with an ",identity" tag and get its value
for _, field := range s.Fields() {
if tag := field.Tag(RecordStructTag); tag != `` {
v := strings.Split(tag, `,`)
if sliceutil.ContainsString(v[1:], `identity`) {
if v[0] != `` {
return field.Name(), v[0], nil
} else {
return field.Name(), field.Name(), nil
}
}
}
}
if fallbackIdentityFieldName == `` {
fallbackIdentityFieldName = DefaultStructIdentityFieldName
}
if _, ok := s.FieldOk(fallbackIdentityFieldName); ok {
return fallbackIdentityFieldName, fallbackIdentityFieldName, nil
} else if _, ok := s.FieldOk(DefaultStructIdentityFieldName); ok {
return DefaultStructIdentityFieldName, DefaultStructIdentityFieldName, nil
}
return ``, ``, fmt.Errorf("No identity field could be found for type %T", instance)
} | go | {
"resource": ""
} |
q17351 | Scheme | train | func (self *ConnectionString) Scheme() (string, string) {
backend, protocol := stringutil.SplitPair(self.URI.Scheme, `+`)
return backend, strings.Trim(protocol, `/`)
} | go | {
"resource": ""
} |
q17352 | Protocol | train | func (self *ConnectionString) Protocol(defaults ...string) string {
if _, protocol := self.Scheme(); protocol != `` {
return protocol
} else if len(defaults) > 0 {
return defaults[0]
} else {
return ``
}
} | go | {
"resource": ""
} |
q17353 | Host | train | func (self *ConnectionString) Host(defaults ...string) string {
if host := self.URI.Host; host != `` {
return host
} else if len(defaults) > 0 {
return defaults[0]
} else {
return ``
}
} | go | {
"resource": ""
} |
q17354 | Dataset | train | func (self *ConnectionString) Dataset() string {
dataset := self.URI.Path
dataset = strings.TrimPrefix(dataset, `/`)
dataset = strings.TrimSuffix(dataset, `/`)
return dataset
} | go | {
"resource": ""
} |
q17355 | SetCredentials | train | func (self *ConnectionString) SetCredentials(username string, password string) {
self.URI.User = url.UserPassword(username, password)
} | go | {
"resource": ""
} |
q17356 | LoadCredentialsFromNetrc | train | func (self *ConnectionString) LoadCredentialsFromNetrc(filename string) error {
if u := self.URI.User; u == nil && filename != `` {
filename = fileutil.MustExpandUser(filename)
if fileutil.IsNonemptyFile(filename) {
if netrcFile, err := netrc.Parse(filename); err == nil {
if machine := netrcFile.Machine(self.URI.Hostname()); machine != nil {
log.Debugf("Reading credentials from %v for host %v", filename, machine.Name)
login := machine.Get(`login`)
password := machine.Get(`password`)
if login != `` || password != `` {
self.URI.User = url.UserPassword(login, password)
}
}
} else {
return fmt.Errorf("netrc error: %v", err)
}
}
}
return nil
} | go | {
"resource": ""
} |
q17357 | NewCollection | train | func NewCollection(name string) *Collection {
return &Collection{
Name: name,
Fields: make([]Field, 0),
IdentityField: DefaultIdentityField,
IdentityFieldType: DefaultIdentityFieldType,
IdentityFieldValidator: ValidateNotEmpty,
}
} | go | {
"resource": ""
} |
q17358 | TTL | train | func (self *Collection) TTL(record *Record) time.Duration {
if self.TimeToLiveField != `` {
if value := record.Get(self.TimeToLiveField); !typeutil.IsZero(value) {
if expireAt := typeutil.V(value).Time(); !expireAt.IsZero() {
return expireAt.Sub(time.Now())
}
}
}
return 0
} | go | {
"resource": ""
} |
q17359 | IsExpired | train | func (self *Collection) IsExpired(record *Record) bool {
if self.TTL(record) < 0 {
return true
} else {
return false
}
} | go | {
"resource": ""
} |
q17360 | GetIndexName | train | func (self *Collection) GetIndexName() string {
if self.IndexName != `` {
return self.IndexName
}
return self.Name
} | go | {
"resource": ""
} |
q17361 | GetAggregatorName | train | func (self *Collection) GetAggregatorName() string {
if self.IndexName != `` {
return self.IndexName
}
return self.Name
} | go | {
"resource": ""
} |
q17362 | SetIdentity | train | func (self *Collection) SetIdentity(name string, idtype Type, formatter FieldFormatterFunc, validator FieldValidatorFunc) *Collection {
if name != `` {
self.IdentityField = name
}
self.IdentityFieldType = idtype
if formatter != nil {
self.IdentityFieldFormatter = formatter
}
if validator != nil {
self.IdentityFieldValidator = validator
}
return self
} | go | {
"resource": ""
} |
q17363 | AddFields | train | func (self *Collection) AddFields(fields ...Field) *Collection {
self.Fields = append(self.Fields, fields...)
return self
} | go | {
"resource": ""
} |
q17364 | ApplyDefinition | train | func (self *Collection) ApplyDefinition(definition *Collection) error {
if definition != nil {
if v := definition.IdentityField; v != `` {
self.IdentityField = v
}
if v := definition.IdentityFieldType; v != `` {
self.IdentityFieldType = v
}
if fn := definition.IdentityFieldFormatter; fn != nil {
self.IdentityFieldFormatter = fn
}
if fn := definition.IdentityFieldValidator; fn != nil {
self.IdentityFieldValidator = fn
}
for i, field := range self.Fields {
if defField, ok := definition.GetField(field.Name); ok {
if field.Description == `` {
self.Fields[i].Description = defField.Description
}
if field.Length == 0 && defField.Length != 0 {
self.Fields[i].Length = defField.Length
}
if field.Precision == 0 && defField.Precision != 0 {
self.Fields[i].Precision = defField.Precision
}
// unconditionally pull these over as they are either client-only fields or we know better
// than the database on this one
self.Fields[i].Required = defField.Required
self.Fields[i].Type = defField.Type
self.Fields[i].KeyType = defField.KeyType
self.Fields[i].Subtype = defField.Subtype
self.Fields[i].DefaultValue = defField.DefaultValue
self.Fields[i].ValidateOnPopulate = defField.ValidateOnPopulate
self.Fields[i].Validator = defField.Validator
self.Fields[i].Formatter = defField.Formatter
} else {
return fmt.Errorf("Definition is missing field %q", field.Name)
}
}
}
return nil
} | go | {
"resource": ""
} |
q17365 | GetField | train | func (self *Collection) GetField(name string) (Field, bool) {
if name == self.GetIdentityFieldName() {
return Field{
Name: name,
Type: self.IdentityFieldType,
Index: self.IdentityFieldIndex,
Identity: true,
Key: true,
Required: true,
}, true
} else {
for _, field := range self.Fields {
if field.Name == name {
return field, true
}
}
}
return Field{}, false
} | go | {
"resource": ""
} |
q17366 | GetFieldByIndex | train | func (self *Collection) GetFieldByIndex(index int) (Field, bool) {
if index == self.IdentityFieldIndex {
return Field{
Name: self.GetIdentityFieldName(),
Type: self.IdentityFieldType,
Index: self.IdentityFieldIndex,
Identity: true,
Key: true,
Required: true,
}, true
} else {
for _, field := range self.Fields {
if field.Index == index {
return field, true
}
}
}
return Field{}, false
} | go | {
"resource": ""
} |
q17367 | IsKeyField | train | func (self *Collection) IsKeyField(name string) bool {
if field, ok := self.GetField(name); ok {
return (field.Key && !field.Identity)
}
return false
} | go | {
"resource": ""
} |
q17368 | KeyFields | train | func (self *Collection) KeyFields() []Field {
keys := []Field{
Field{
Name: self.GetIdentityFieldName(),
Type: self.IdentityFieldType,
Identity: true,
Key: true,
Required: true,
},
}
// append additional key fields
for _, field := range self.Fields {
if field.Key {
keys = append(keys, field)
}
}
return keys
} | go | {
"resource": ""
} |
q17369 | GetFirstNonIdentityKeyField | train | func (self *Collection) GetFirstNonIdentityKeyField() (Field, bool) {
for _, field := range self.Fields {
if field.Key && !field.Identity {
return field, true
}
}
return Field{}, false
} | go | {
"resource": ""
} |
q17370 | ConvertValue | train | func (self *Collection) ConvertValue(name string, value interface{}) interface{} {
if field, ok := self.GetField(name); ok {
if v, err := field.ConvertValue(value); err == nil {
return v
}
}
return value
} | go | {
"resource": ""
} |
q17371 | MapFromRecord | train | func (self *Collection) MapFromRecord(record *Record, fields ...string) (map[string]interface{}, error) {
rv := make(map[string]interface{})
for _, field := range self.Fields {
if len(fields) > 0 && !sliceutil.ContainsString(fields, field.Name) {
continue
}
if dv := field.GetDefaultValue(); dv != nil {
rv[field.Name] = dv
}
}
if record != nil {
if record.ID != nil {
if id, err := self.formatAndValidateId(record.ID, RetrieveOperation, record); err == nil {
rv[self.GetIdentityFieldName()] = id
} else {
return nil, err
}
}
if len(self.Fields) > 0 {
for _, field := range self.Fields {
if v := record.Get(field.Name); v != nil {
if len(fields) > 0 && !sliceutil.ContainsString(fields, field.Name) {
continue
}
rv[field.Name] = v
}
}
} else {
for k, v := range record.Fields {
rv[k] = v
}
}
}
return rv, nil
} | go | {
"resource": ""
} |
q17372 | ValidateRecord | train | func (self *Collection) ValidateRecord(record *Record, op FieldOperation) error {
switch op {
case PersistOperation:
// validate whole record (if specified)
if self.PreSaveValidator != nil {
if err := self.PreSaveValidator(record); err != nil {
return err
}
}
}
return nil
} | go | {
"resource": ""
} |
q17373 | Check | train | func (self *Collection) Check() error {
var merr error
for i, field := range self.Fields {
if field.Name == `` {
merr = log.AppendError(merr, fmt.Errorf("collection[%s] field #%d cannot have an empty name", self.Name, i))
}
if ParseFieldType(string(field.Type)) == `` {
merr = log.AppendError(merr, fmt.Errorf("collection[%s] field[%s]: invalid type %q", self.Name, field.Name, field.Type))
}
}
return merr
} | go | {
"resource": ""
} |
q17374 | Get | train | func (self *Model) Get(id interface{}, into interface{}) error {
if record, err := self.db.Retrieve(self.collection.Name, id); err == nil {
return record.Populate(into, self.collection)
} else {
return err
}
} | go | {
"resource": ""
} |
q17375 | Exists | train | func (self *Model) Exists(id interface{}) bool {
return self.db.Exists(self.collection.Name, id)
} | go | {
"resource": ""
} |
q17376 | Update | train | func (self *Model) Update(from interface{}) error {
if record, err := self.collection.MakeRecord(from); err == nil {
return self.db.Update(self.collection.Name, dal.NewRecordSet(record))
} else {
return err
}
} | go | {
"resource": ""
} |
q17377 | CreateOrUpdate | train | func (self *Model) CreateOrUpdate(id interface{}, from interface{}) error {
if id == nil || !self.Exists(id) {
return self.Create(from)
} else {
return self.Update(from)
}
} | go | {
"resource": ""
} |
q17378 | Delete | train | func (self *Model) Delete(ids ...interface{}) error {
return self.db.Delete(self.collection.Name, ids...)
} | go | {
"resource": ""
} |
q17379 | DeleteQuery | train | func (self *Model) DeleteQuery(flt interface{}) error {
if f, err := self.filterFromInterface(flt); err == nil {
f.IdentityField = self.collection.IdentityField
if search := self.db.WithSearch(self.collection, f); search != nil {
return search.DeleteQuery(self.collection, f)
} else {
return fmt.Errorf("backend %T does not support searching", self.db)
}
} else {
return err
}
} | go | {
"resource": ""
} |
q17380 | Find | train | func (self *Model) Find(flt interface{}, into interface{}) error {
if f, err := self.filterFromInterface(flt); err == nil {
f.IdentityField = self.collection.IdentityField
if search := self.db.WithSearch(self.collection, f); search != nil {
// perform query
if recordset, err := search.Query(self.collection, f); err == nil {
return self.populateOutputParameter(f, recordset, into)
} else {
return err
}
} else {
return fmt.Errorf("backend %T does not support searching", self.db)
}
} else {
return err
}
} | go | {
"resource": ""
} |
q17381 | FindFunc | train | func (self *Model) FindFunc(flt interface{}, destZeroValue interface{}, resultFn ResultFunc) error {
if f, err := self.filterFromInterface(flt); err == nil {
f.IdentityField = self.collection.IdentityField
if search := self.db.WithSearch(self.collection, f); search != nil {
_, err := search.Query(self.collection, f, func(record *dal.Record, err error, _ backends.IndexPage) error {
if err == nil {
if _, ok := destZeroValue.(*dal.Record); ok {
resultFn(record, nil)
} else if _, ok := destZeroValue.(dal.Record); ok {
resultFn(*record, nil)
} else {
into := reflect.New(reflect.TypeOf(destZeroValue)).Interface()
// populate that type with data from this record
if err := record.Populate(into, self.collection); err == nil {
resultFn(into, nil)
} else {
return err
}
}
} else {
resultFn(nil, err)
}
return nil
})
return err
} else {
return fmt.Errorf("backend %T does not support searching", self.db)
}
} else {
return err
}
} | go | {
"resource": ""
} |
q17382 | GenerateUUID | train | func GenerateUUID(value interface{}, _ FieldOperation) (interface{}, error) {
if record, ok := value.(*Record); ok {
value = record.ID
}
if typeutil.IsZero(value) {
value = stringutil.UUID().String()
}
return value, nil
} | go | {
"resource": ""
} |
q17383 | GenerateEncodedUUID | train | func GenerateEncodedUUID(encoder EncoderFunc) FieldFormatterFunc {
return func(value interface{}, _ FieldOperation) (interface{}, error) {
if record, ok := value.(*Record); ok {
value = record.ID
}
if typeutil.IsZero(value) {
if v, err := encoder(stringutil.UUID().Bytes()); err == nil {
if typeutil.IsZero(v) {
return value, fmt.Errorf("UUID encoder produced a zero-length result")
}
value = v
} else {
return value, err
}
}
return value, nil
}
} | go | {
"resource": ""
} |
q17384 | IfUnset | train | func IfUnset(onlyIf FieldFormatterFunc) FieldFormatterFunc {
return func(value interface{}, op FieldOperation) (interface{}, error) {
if onlyIf != nil {
if typeutil.IsZero(value) {
return onlyIf(value, op)
}
}
return value, nil
}
} | go | {
"resource": ""
} |
q17385 | DeriveFromFields | train | func DeriveFromFields(format string, fields ...string) FieldFormatterFunc {
return func(input interface{}, _ FieldOperation) (interface{}, error) {
if record, ok := input.(*Record); ok {
values := make([]interface{}, len(fields))
for i, field := range fields {
values[i] = record.Get(field)
}
return fmt.Sprintf(format, values...), nil
} else {
return nil, fmt.Errorf("DeriveFromFields formatter requires a *dal.Record argument, got %T", input)
}
}
} | go | {
"resource": ""
} |
q17386 | CurrentTime | train | func CurrentTime(value interface{}, op FieldOperation) (interface{}, error) {
if op == PersistOperation {
return time.Now(), nil
} else {
return value, nil
}
} | go | {
"resource": ""
} |
q17387 | CurrentTimeIfUnset | train | func CurrentTimeIfUnset(value interface{}, op FieldOperation) (interface{}, error) {
return IfUnset(func(v interface{}, o FieldOperation) (interface{}, error) {
if o == PersistOperation {
return time.Now(), nil
} else {
return v, nil
}
})(value, op)
} | go | {
"resource": ""
} |
q17388 | NowPlusDuration | train | func NowPlusDuration(duration time.Duration) FieldFormatterFunc {
return func(value interface{}, op FieldOperation) (interface{}, error) {
if op == PersistOperation {
if duration != 0 {
return time.Now().Add(duration), nil
}
}
return value, nil
}
} | go | {
"resource": ""
} |
q17389 | ValidateMatchAll | train | func ValidateMatchAll(patterns ...string) FieldValidatorFunc {
prx := make([]*regexp.Regexp, len(patterns))
for i, rxs := range patterns {
prx[i] = regexp.MustCompile(rxs)
}
return func(value interface{}) error {
for _, rx := range prx {
if !rx.MatchString(typeutil.String(value)) {
return fmt.Errorf("Value does not match pattern %q", rx.String())
}
}
return nil
}
} | go | {
"resource": ""
} |
q17390 | ValidateAll | train | func ValidateAll(validators ...FieldValidatorFunc) FieldValidatorFunc {
return func(value interface{}) error {
for _, validator := range validators {
if err := validator(value); err != nil {
return err
}
}
return nil
}
} | go | {
"resource": ""
} |
q17391 | ValidateIsOneOf | train | func ValidateIsOneOf(choices ...interface{}) FieldValidatorFunc {
return func(value interface{}) error {
for _, choice := range choices {
if ok, err := stringutil.RelaxedEqual(choice, value); err == nil && ok {
return nil
}
}
return fmt.Errorf("value must be one of: %+v", choices)
}
} | go | {
"resource": ""
} |
q17392 | ValidateNotEmpty | train | func ValidateNotEmpty(value interface{}) error {
if typeutil.IsEmpty(value) {
return fmt.Errorf("expected non-empty value, got: %v", value)
}
return nil
} | go | {
"resource": ""
} |
q17393 | ValidatePositiveInteger | train | func ValidatePositiveInteger(value interface{}) error {
if v, err := stringutil.ConvertToInteger(value); err == nil {
if v <= 0 {
return fmt.Errorf("expected value > 0, got: %v", v)
}
} else {
return err
}
return nil
} | go | {
"resource": ""
} |
q17394 | ValidateIsURL | train | func ValidateIsURL(value interface{}) error {
if u, err := url.Parse(typeutil.String(value)); err == nil {
if u.Scheme == `` || u.Host == `` || u.Path == `` {
return fmt.Errorf("Invalid URL")
}
} else {
return err
}
return nil
} | go | {
"resource": ""
} |
q17395 | run | train | func (self *RedisBackend) run(cmd string, args ...interface{}) (interface{}, error) {
if conn := self.pool.Get(); conn != nil {
defer conn.Close()
// debug := strings.Join(sliceutil.Stringify(args), ` `)
// querylog.Debugf("[%v] %v %v", self, cmd, debug)
return redis.DoWithTimeout(conn, self.cmdTimeout, cmd, args...)
} else {
return nil, fmt.Errorf("Failed to borrow Redis connection")
}
} | go | {
"resource": ""
} |
q17396 | DeleteQuery | train | func (self *SqlBackend) DeleteQuery(collection *dal.Collection, f *filter.Filter) error {
if tx, err := self.db.Begin(); err == nil {
queryGen := self.makeQueryGen(collection)
queryGen.Type = generators.SqlDeleteStatement
// generate SQL
if stmt, err := filter.Render(queryGen, collection.Name, f); err == nil {
querylog.Debugf("[%v] %s %v", self, string(stmt[:]), queryGen.GetValues())
// execute SQL
if _, err := tx.Exec(string(stmt[:]), queryGen.GetValues()...); err == nil {
if err := tx.Commit(); err == nil {
return nil
} else {
return err
}
} else {
defer tx.Rollback()
return err
}
} else {
defer tx.Rollback()
return err
}
} else {
return err
}
} | go | {
"resource": ""
} |
q17397 | PopulateFromRecords | train | func (self *RecordSet) PopulateFromRecords(into interface{}, schema *Collection) error {
vInto := reflect.ValueOf(into)
// get value pointed to if we were given a pointer
if vInto.Kind() == reflect.Ptr {
vInto = vInto.Elem()
} else {
return fmt.Errorf("Output argument must be a pointer")
}
// we're going to fill arrays or slices
switch vInto.Type().Kind() {
case reflect.Array, reflect.Slice:
indirectResult := true
// get the type of the underlying slice element
sliceType := vInto.Type().Elem()
// get the type pointed to
if sliceType.Kind() == reflect.Ptr {
sliceType = sliceType.Elem()
indirectResult = false
}
// for each resulting record...
for _, record := range self.Records {
// make a new zero-valued instance of the slice type
elem := reflect.New(sliceType)
// if we have a registered collection, use its
if schema != nil && schema.HasRecordType() {
elem = reflect.ValueOf(schema.NewInstance())
}
// populate that type with data from this record
if err := record.Populate(elem.Interface(), schema); err == nil {
// if the slice elements are pointers, we can append the pointer we just created as-is
// otherwise, we need to indirect the value and append a copy
if indirectResult {
vInto.Set(reflect.Append(vInto, reflect.Indirect(elem)))
} else {
vInto.Set(reflect.Append(vInto, elem))
}
} else {
return err
}
}
return nil
case reflect.Struct:
if rs, ok := into.(*RecordSet); ok {
*rs = *self
return nil
}
}
return fmt.Errorf("RecordSet can only populate records into slice or array, got %T", into)
} | go | {
"resource": ""
} |
q17398 | Populate | train | func (self *Record) Populate(into interface{}, collection *Collection) error {
// special case for what is essentially copying another record into this one
if record, ok := into.(*Record); ok {
return self.Copy(record, collection)
} else {
if err := validatePtrToStructType(into); err != nil {
return err
}
// if the struct we got is a zero value, and we've been given a collection,
// use it with NewInstance
if collection != nil {
if typeutil.IsZero(into) {
into = collection.NewInstance()
}
}
var idFieldName string
var fallbackIdFieldName string
// if a collection is specified, set the fallback identity field name to what the collection
// knows the ID field is called. This is used for input structs that don't explicitly tag
// a field with the ",identity" option
if collection != nil {
idFieldName = collection.GetIdentityFieldName()
}
// get the name of the identity field from the given struct
if _, key, err := getIdentityFieldNameFromStruct(into, fallbackIdFieldName); err == nil && key != `` {
idFieldName = key
} else if err != nil {
return err
} else {
return fmt.Errorf("Could not determine identity field name")
}
if data, err := self.toMap(collection, idFieldName); err == nil {
return maputil.TaggedStructFromMap(data, into, RecordStructTag)
} else {
return err
}
}
} | go | {
"resource": ""
} |
q17399 | NewContext | train | func NewContext(parent context.Context, logger lager.Logger) context.Context {
return context.WithValue(parent, contextKey{}, logger)
} | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.