_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... | 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 :... | 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, ... | 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))
... | 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 == ... | 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)
i... | 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 ... | 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 error... | 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)
}... | 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.... | 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, "Er... | 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,
cfE... | 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)
... | 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 requ... | 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.NewDe... | 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 {
retu... | 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... | 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 termi... | 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 e... | 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 =... | 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.Spri... | 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.U... | 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... | 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 {
retu... | 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, 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.Int... | 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.YCbCrSubsampleR... | 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 &Converter... | 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(d... | 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.Vert... | 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)) >> Bi... | 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 {
retur... | 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() {... | 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) / floa... | 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.Field... | 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(s... | 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.Id... | 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 {
s... | 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.... | 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 {
fo... | 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 = appen... | 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 {
... | 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.E... | 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("ba... | 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,... | 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.collecti... | 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.Is... | 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... | 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("V... | 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, ... | 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 ... | 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... | 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
}
... | 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.