id stringlengths 2 7 | text stringlengths 17 51.2k | title stringclasses 1
value |
|---|---|---|
c26000 |
}
var fullRoutesList []Route
warnings, err := client.paginate(request, Route{}, func(item interface{}) error {
if route, ok := item.(Route); ok {
fullRoutesList = append(fullRoutesList, route)
} else {
return ccerror.UnknownObjectInListError{
Expected: Route{},
Unexpected: item,
}
}
retu... | |
c26001 | := item.(Route); ok {
fullRoutesList = append(fullRoutesList, route)
} else {
return ccerror.UnknownObjectInListError{
Expected: Route{},
Unexpected: item,
}
}
return nil
})
return fullRoutesList, warnings, err
} | |
c26002 | Route
response := cloudcontroller.Response{
DecodeJSONResponseInto: &route,
}
err = client.connection.Make(request, &response)
return route, response.Warnings, err
} | |
c26003 |
var responseProcess Process
response := cloudcontroller.Response{
DecodeJSONResponseInto: &responseProcess,
}
err = client.connection.Make(request, &response)
return responseProcess, response.Warnings, err
} | |
c26004 | }
var process Process
response := cloudcontroller.Response{
DecodeJSONResponseInto: &process,
}
err = client.connection.Make(request, &response)
return process, response.Warnings, err
} | |
c26005 | bytes.NewReader(body),
URIParams: internal.Params{"process_guid": process.GUID},
})
if err != nil {
return Process{}, nil, err
}
var responseProcess Process
response := cloudcontroller.Response{
DecodeJSONResponseInto: &responseProcess,
}
err = client.connection.Make(request, &response)
return respon... | |
c26006 | fullSharedToList = append(fullSharedToList, instance)
} else {
return ccerror.UnknownObjectInListError{
Expected: ServiceInstanceSharedTo{},
Unexpected: item,
}
}
return nil
})
return fullSharedToList, warnings, err
} | |
c26007 | TLSClientConfig: &tls.Config{
InsecureSkipVerify: skipSSLValidation,
},
}
return &UAAConnection{
HTTPClient: &http.Client{
Transport: tr,
CheckRedirect: func(_ *http.Request, _ []*http.Request) error {
// This prevents redirects. When making a request to /oauth/authorize,
// the client should n... | |
c26008 | passedResponse.reset()
response, err := connection.HTTPClient.Do(request)
if err != nil {
return connection.processRequestErrors(request, err)
}
return connection.populateResponse(response, passedResponse)
} | |
c26009 | event.GUID = ccEvent.Metadata.GUID
event.Type = constant.EventType(ccEvent.Entity.Type)
event.ActorGUID = ccEvent.Entity.ActorGUID
event.ActorType = ccEvent.Entity.ActorType
event.ActorName = ccEvent.Entity.ActorName
event.ActeeGUID = ccEvent.Entity.ActeeGUID
event.ActeeType = ccEvent.Entity.ActeeType
event.Act... | |
c26010 |
}
var fullEventsList []Event
warnings, err := client.paginate(request, Event{}, func(item interface{}) error {
if event, ok := item.(Event); ok {
fullEventsList = append(fullEventsList, event)
} else {
return ccerror.UnknownObjectInListError{
Expected: Event{},
Unexpected: item,
}
}
retu... | |
c26011 | return err
}
r.Filename = ccResource.Filename
r.Size = ccResource.Size
r.SHA1 = ccResource.SHA1
mode, err := strconv.ParseUint(ccResource.Mode, 8, 32)
if err != nil {
return err
}
r.Mode = os.FileMode(mode)
return nil
} | |
c26012 | },
Body: strings.NewReader(requestBody.Encode()),
Query: query,
})
if err != nil {
return "", "", err
}
if grantType == constant.GrantTypePassword {
request.SetBasicAuth(client.config.UAAOAuthClient(), client.config.UAAOAuthClientSecret())
}
responseBody := AuthResponse{}
response := Response{
Re... | |
c26013 |
if err != nil {
return err
}
application.GUID = ccOrgQuota.Metadata.GUID
application.Name = ccOrgQuota.Entity.Name
return nil
} | |
c26014 | err
}
var orgQuota OrganizationQuota
response := cloudcontroller.Response{
DecodeJSONResponseInto: &orgQuota,
}
err = client.connection.Make(request, &response)
return orgQuota, response.Warnings, err
} | |
c26015 | return []OrganizationQuota{}, nil, err
}
var fullOrgQuotasList []OrganizationQuota
warnings, err := client.paginate(request, OrganizationQuota{}, func(item interface{}) error {
if org, ok := item.(OrganizationQuota); ok {
fullOrgQuotasList = append(fullOrgQuotasList, org)
} else {
return ccerror.Unknow... | |
c26016 |
return Process{}, Warnings(warnings), actionerror.ProcessNotFoundError{ProcessType: processType}
}
return Process(process), Warnings(warnings), err
} | |
c26017 |
case "null", "default":
n.Value = ""
default:
n.Value = val
}
} | |
c26018 | != "" {
return json.Marshal(n.Value)
}
return json.Marshal(new(json.RawMessage))
} | |
c26019 | := json.NewDecoder(bytes.NewBuffer(raw))
decoder.UseNumber()
return decoder.Decode(v)
} | |
c26020 | ccDeployment.Droplet = &Droplet{d.DropletGUID}
}
ccDeployment.Relationships = d.Relationships
return json.Marshal(ccDeployment)
} | |
c26021 | `json:"droplet,omitempty"`
}
err := cloudcontroller.DecodeJSON(data, &ccDeployment)
if err != nil {
return err
}
d.GUID = ccDeployment.GUID
d.CreatedAt = ccDeployment.CreatedAt
d.Relationships = ccDeployment.Relationships
d.State = ccDeployment.State
d.DropletGUID = ccDeployment.Droplet.GUID
return n... | |
c26022 | }
By("errors if user not logged in")
LogoutCF()
session := CF(command...)
Eventually(session).Should(Say("FAILED"))
Eventually(session.Err).Should(Say("Not logged in\\. Use 'cf login' to log in\\."))
Eventually(session).Should(Exit(1))
By("errors if cli not targeted")
UnsetAPI()
session = CF(command...)
Ev... | |
c26023 | manifest.Applications {
if app.Path != "" && !filepath.IsAbs(app.Path) {
manifest.Applications[i].Path = filepath.Join(filepath.Dir(pathToManifest), app.Path)
}
}
return manifest.Applications, err
} | |
c26024 | != nil {
return nil, InvalidYAMLError{Err: err}
}
for k, v := range sv {
fileVars[k] = v
}
}
for _, kv := range vars {
fileVars[kv.Name] = kv.Value
}
rawManifest, err = tpl.Evaluate(fileVars, nil, template.EvaluateOpts{ExpectAllKeys: true})
if err != nil {
return nil, InterpolationError{Err: er... | |
c26025 | err = ioutil.WriteFile(filePath, manifestBytes, 0644)
if err != nil {
return ManifestCreationError{Err: err}
}
return nil
} | |
c26026 | var isolationSegment IsolationSegment
response := cloudcontroller.Response{
DecodeJSONResponseInto: &isolationSegment,
}
err = client.connection.Make(request, &response)
if err != nil {
return IsolationSegment{}, response.Warnings, err
}
return isolationSegment, response.Warnings, nil
} | |
c26027 | ok {
fullIsolationSegmentsList = append(fullIsolationSegmentsList, isolationSegment)
} else {
return ccerror.UnknownObjectInListError{
Expected: IsolationSegment{},
Unexpected: item,
}
}
return nil
})
return fullIsolationSegmentsList, warnings, err
} | |
c26028 |
return 0, err
}
err = form.Close()
if err != nil {
return 0, err
}
return int64(body.Len()) + buildpackSize, nil
} | |
c26029 | make([]SecurityGroupRule, len(ccSecurityGroup.Entity.Rules))
for i, ccRule := range ccSecurityGroup.Entity.Rules {
securityGroup.Rules[i].Description = ccRule.Description
securityGroup.Rules[i].Destination = ccRule.Destination
securityGroup.Rules[i].Ports = ccRule.Ports
securityGroup.Rules[i].Protocol = ccRul... | |
c26030 | URIParams: Params{
"security_group_guid": securityGroupGUID,
"space_guid": spaceGUID,
},
})
if err != nil {
return nil, err
}
response := cloudcontroller.Response{}
err = client.connection.Make(request, &response)
return response.Warnings, err
} | |
c26031 |
var securityGroupsList []SecurityGroup
warnings, err := client.paginate(request, SecurityGroup{}, func(item interface{}) error {
if securityGroup, ok := item.(SecurityGroup); ok {
securityGroupsList = append(securityGroupsList, securityGroup)
} else {
return ccerror.UnknownObjectInListError{
Expected:... | |
c26032 | return client.getSpaceSecurityGroupsBySpaceAndLifecycle(spaceGUID, internal.GetSpaceSecurityGroupsRequest, filters)
} | |
c26033 | return client.getSpaceSecurityGroupsBySpaceAndLifecycle(spaceGUID, internal.GetSpaceStagingSecurityGroupsRequest, filters)
} | |
c26034 | errs = append(errs, ccerror.BuildpackStackDoesNotExistError{Message: errDetails.Detail})
case constant.JobErrorCodeBuildpackZipInvalid:
errs = append(errs, ccerror.BuildpackZipInvalidError{Message: errDetails.Detail})
default:
errs = append(errs, ccerror.V3JobFailedError{
JobGUID: job.GUID,
Code: ... | |
c26035 | },
})
if err != nil {
if _, ok := err.(ccerror.NameNotUniqueInSpaceError); ok {
return Application{}, Warnings(warnings), actionerror.ApplicationAlreadyExistsError{Name: app.Name}
}
return Application{}, Warnings(warnings), err
}
return actor.convertCCToActorApplication(createdApp), Warnings(warnings),... | |
c26036 | err := actor.UpdateProcessByTypeAndApplication(
processType,
app.GUID,
Process{
HealthCheckType: healthCheckType,
HealthCheckEndpoint: httpEndpoint,
HealthCheckInvocationTimeout: invocationTimeout,
})
return app, append(getWarnings, setWarnings...), err
} | |
c26037 | warnings, err := actor.CloudControllerClient.UpdateApplicationStop(appGUID)
return Warnings(warnings), err
} | |
c26038 | Application{}, Warnings(warnings), err
}
return actor.convertCCToActorApplication(updatedApp), Warnings(warnings), nil
} | |
c26039 |
pollingWarnings, err := actor.PollStart(appGUID)
allWarnings = append(allWarnings, pollingWarnings...)
return allWarnings, err
} | |
c26040 |
return fmt.Sprintf("Domain with GUID %s not found", e.GUID)
default:
return "Domain not found"
}
} | |
c26041 |
Expect(err).ToNot(HaveOccurred())
err = ioutil.WriteFile(filepath.Join(dir, "Gemfile.lock"), []byte(`
GEM
specs:
PLATFORMS
ruby
DEPENDENCIES
BUNDLED WITH
1.15.0
`), 0666)
Expect(err).ToNot(HaveOccurred())
f(dir)
} | |
c26042 |
Eventually(session).Should(Exit(0))
return strings.TrimSpace(string(session.Out.Contents()))
} | |
c26043 | = ioutil.WriteFile(path, body, 0666)
Expect(err).ToNot(HaveOccurred())
} | |
c26044 |
}
header.Name = filepath.ToSlash(header.Name)
if info.IsDir() {
header.Name += "/"
header.SetMode(0755)
} else {
header.Method = zip.Deflate
header.SetMode(0744)
}
writer, err := archive.CreateHeader(header)
if err != nil {
return err
}
if info.IsDir() {
return nil
}
file, ... | |
c26045 |
params["q"] = append(params["q"], filter.format())
}
return params
} | |
c26046 | continue
case nil:
if len(reposWithPlugin) == 0 || lessThan(newestPluginInfo.Version, pluginInfo.Version) {
newestPluginInfo = pluginInfo
reposWithPlugin = []string{repo.Name}
} else if pluginInfo.Version == newestPluginInfo.Version {
reposWithPlugin = append(reposWithPlugin, repo.Name)
}
def... | |
c26047 | return generic.GeneratePlatform(runtime.GOOS, runtime.GOARCH)
} | |
c26048 | }, nil
}
}
pluginFoundWithIncompatibleBinary = true
}
}
if pluginFoundWithIncompatibleBinary {
return PluginInfo{}, actionerror.NoCompatibleBinaryError{}
}
return PluginInfo{}, actionerror.PluginNotFoundInRepositoryError{
PluginName: pluginName,
RepositoryName: pluginRepo.Name,
}
} | |
c26049 | return name
}
return fmt.Sprintf("%s.exe", name)
} | |
c26050 | RequestName: internal.PostIsolationSegmentRelationshipOrganizationsRequest,
URIParams: internal.Params{"isolation_segment_guid": isolationSegmentGUID},
Body: bytes.NewReader(body),
})
if err != nil {
return RelationshipList{}, nil, err
}
var relationships RelationshipList
response := cloudcontroll... | |
c26051 | internal.PostServiceInstanceRelationshipsSharedSpacesRequest,
URIParams: internal.Params{"service_instance_guid": serviceInstanceGUID},
Body: bytes.NewReader(body),
})
if err != nil {
return RelationshipList{}, nil, err
}
var relationships RelationshipList
response := cloudcontroller.Response{
... | |
c26052 |
templateErr := formattedTemplate.Execute(os.Stderr, map[string]interface{}{
"Binary": os.Args[0],
"Command": strings.Join(os.Args, " "),
"Version": version.VersionString(),
"StackTrace": stackTrace,
"Error": err,
})
if templateErr != nil {
fmt.Fprintf(os.Stderr,
"Unable to fo... | |
c26053 |
}
domain.GUID = ccDomain.Metadata.GUID
domain.Name = ccDomain.Entity.Name
domain.RouterGroupGUID = ccDomain.Entity.RouterGroupGUID
domain.RouterGroupType = constant.RouterGroupType(ccDomain.Entity.RouterGroupType)
domain.Internal = ccDomain.Entity.Internal
return nil
} | |
c26054 | client.connection.Make(request, &response)
if err != nil {
return Domain{}, response.Warnings, err
}
domain.Type = constant.PrivateDomain
return domain, response.Warnings, nil
} | |
c26055 | fullDomainsList = append(fullDomainsList, domain)
} else {
return ccerror.UnknownObjectInListError{
Expected: Domain{},
Unexpected: item,
}
}
return nil
})
return fullDomainsList, warnings, err
} | |
c26056 | := cType.FieldByNameFunc(
func(fieldName string) bool {
field, _ := cType.FieldByName(fieldName)
return field.Tag.Get("command") == name
},
)
return found
} | |
c26057 | logLine := fmt.Sprintf("%s%s", header, strings.TrimRight(line, "\r\n"))
if message.Type() == "ERR" {
logLine = ui.modifyColor(logLine, color.New(color.FgRed))
}
fmt.Fprintf(ui.Out, " %s\n", logLine)
}
} | |
c26058 | RepositoryName: fetchErr.RepositoryName,
}
case pluginerror.SSLValidationHostnameError:
return translatableerror.FetchingPluginInfoFromRepositoriesError{
Message: clientErr.Error(),
RepositoryName: fetchErr.RepositoryName,
}
case pluginerror.UnverifiedServerError:
return translatableerror.Fet... | |
c26059 |
var responseEnvVars Environment
response := cloudcontroller.Response{
DecodeJSONResponseInto: &responseEnvVars,
}
err = client.connection.Make(request, &response)
return responseEnvVars, response.Warnings, err
} | |
c26060 | return ccClient, nil, nil
}
if config.Target() == "" {
return nil, nil, translatableerror.NoAPISetError{
BinaryName: config.BinaryName(),
}
}
_, err := ccClient.TargetCF(ccv2.TargetSettings{
URL: config.Target(),
SkipSSLValidation: config.SkipSSLValidation(),
DialTimeout: config... | |
c26061 | }
}
if targetedSpaceRequired {
if !actor.IsSpaceTargeted() {
return actionerror.NoSpaceTargetedError{
BinaryName: actor.Config.BinaryName(),
}
}
}
}
return nil
} | |
c26062 | URIParams: internal.Params{
"app_guid": appGUID,
},
Body: bytes.NewReader(bodyBytes),
})
if err != nil {
return Task{}, nil, err
}
var responseTask Task
response := cloudcontroller.Response{
DecodeJSONResponseInto: &responseTask,
}
err = client.connection.Make(request, &response)
return responseTa... | |
c26063 | ok := item.(Task); ok {
fullTasksList = append(fullTasksList, task)
} else {
return ccerror.UnknownObjectInListError{
Expected: Task{},
Unexpected: item,
}
}
return nil
})
return fullTasksList, warnings, err
} | |
c26064 | taskGUID,
},
})
if err != nil {
return Task{}, nil, err
}
var task Task
response := cloudcontroller.Response{
DecodeJSONResponseInto: &task,
}
err = client.connection.Make(request, &response)
if err != nil {
return Task{}, response.Warnings, err
}
return task, response.Warnings, nil
} | |
c26065 | return FeatureFlag{}, Warnings(warnings), actionerror.FeatureFlagNotFoundError{FeatureFlagName: featureFlagName}
}
return FeatureFlag{}, Warnings(warnings), err
}
return FeatureFlag(ccv3FeatureFlag), Warnings(warnings), err
} | |
c26066 | serviceInstance.Name = ccServiceInstance.Entity.Name
serviceInstance.SpaceGUID = ccServiceInstance.Entity.SpaceGUID
serviceInstance.ServiceGUID = ccServiceInstance.Entity.ServiceGUID
serviceInstance.ServicePlanGUID = ccServiceInstance.Entity.ServicePlanGUID
serviceInstance.Type = constant.ServiceInstanceType(ccSer... | |
c26067 | bytes.NewReader(bodyBytes),
Query: url.Values{"accepts_incomplete": {"true"}},
})
if err != nil {
return ServiceInstance{}, nil, err
}
var instance ServiceInstance
response := cloudcontroller.Response{
DecodeJSONResponseInto: &instance,
}
err = client.connection.Make(request, &response)
ret... | |
c26068 |
var serviceInstance ServiceInstance
response := cloudcontroller.Response{
DecodeJSONResponseInto: &serviceInstance,
}
err = client.connection.Make(request, &response)
return serviceInstance, response.Warnings, err
} | |
c26069 | fullInstancesList []ServiceInstance
warnings, err := client.paginate(request, ServiceInstance{}, func(item interface{}) error {
if instance, ok := item.(ServiceInstance); ok {
fullInstancesList = append(fullInstancesList, instance)
} else {
return ccerror.UnknownObjectInListError{
Expected: ServiceIns... | |
c26070 | if summary.ServiceInstanceSharedFrom.SpaceGUID != "" {
summary.ServiceInstanceShareType = ServiceInstanceIsSharedFrom
} else {
summary.ServiceInstanceShareType = ServiceInstanceIsNotShared
}
return allWarnings, nil
}
// Service instance is shared to if:
// the targeted space is the same as the source... | |
c26071 | err != nil {
return nil, allWarnings, err
}
var packages []Package
for _, ccv3Package := range ccv3Packages {
packages = append(packages, Package(ccv3Package))
}
return packages, allWarnings, nil
} | |
c26072 |
return Package{}, allWarnings, err
}
pkg = Package(ccPkg)
}
if pkg.State == constant.PackageFailed {
return Package{}, allWarnings, actionerror.PackageProcessingFailedError{}
} else if pkg.State == constant.PackageExpired {
return Package{}, allWarnings, actionerror.PackageProcessingExpiredError{}
}
... | |
c26073 |
password := os.Getenv("CF_INT_PASSWORD")
if password == "" {
password = "admin"
}
return username, password
} | |
c26074 | "" {
Skip("CF_INT_OIDC_USERNAME or CF_INT_OIDC_PASSWORD is not set")
}
return oidcUsername, oidcPassword
} | |
c26075 | externalDomains = append(externalDomains, d)
}
}
if len(externalDomains) == 0 {
log.Error("no domains found")
return v2action.Domain{}, Warnings(warnings), actionerror.NoDomainsFoundError{OrganizationGUID: orgGUID}
}
log.Debugf("selecting first external domain as default domain: %#v", externalDomains)
re... | |
c26076 | expected = fmt.Sprintf(expected, regexp.QuoteMeta(path))
return gbytes.Say(expected)
}
return gbytes.Say(format, theRealPath)
} | |
c26077 | Body: bytes.NewReader(body),
})
if err != nil {
return Buildpack{}, nil, err
}
var createdBuildpack Buildpack
response := cloudcontroller.Response{
DecodeJSONResponseInto: &createdBuildpack,
}
err = client.connection.Make(request, &response)
return createdBuildpack, response.Warnings, err
} | |
c26078 | err
}
var buildpacks []Buildpack
warnings, err := client.paginate(request, Buildpack{}, func(item interface{}) error {
if buildpack, ok := item.(Buildpack); ok {
buildpacks = append(buildpacks, buildpack)
} else {
return ccerror.UnknownObjectInListError{
Expected: Buildpack{},
Unexpected: item,... | |
c26079 | != nil {
return nil, err
}
request.Header.Set("Content-Type", contentType)
request.ContentLength = contentLength
_, warnings, err := client.uploadBuildpackAsynchronously(request, writeErrors)
if err != nil {
return warnings, err
}
return warnings, nil
} | |
c26080 | len(jRunes)
}
for idx := 0; idx < max; idx++ {
ir := iRunes[idx]
jr := jRunes[idx]
lir := unicode.ToLower(ir)
ljr := unicode.ToLower(jr)
if lir == ljr {
continue
}
return lir < ljr
}
return false
} | |
c26081 | warnings, err := actor.CloudControllerClient.GetSpaceSecurityGroups(spaceGUID)
return processSecurityGroups(spaceGUID, ccv2SecurityGroups, Warnings(warnings), err)
} | |
c26082 | warnings, err := actor.CloudControllerClient.GetSpaceStagingSecurityGroups(spaceGUID)
return processSecurityGroups(spaceGUID, ccv2SecurityGroups, Warnings(warnings), err)
} | |
c26083 | = getFilenameFromURL(url)
}
f, err := os.Create(filepath.Join(d.saveDir, d.filename))
if err != nil {
return 0, "", err
}
defer f.Close()
size, err := io.Copy(f, r.Body)
if err != nil {
return 0, "", err
}
d.downloaded = true
return size, d.filename, nil
}
return 0, "", fmt.Errorf("Erro... | |
c26084 | make([]interface{}, 0, slice.Len())
for i := 0; i < slice.Len(); i++ {
contents = append(contents, slice.Index(i).Interface())
}
return contents, err
} | |
c26085 |
if len(ccv2Spaces) == 0 {
return Space{}, Warnings(warnings), actionerror.SpaceNotFoundError{Name: spaceName}
}
if len(ccv2Spaces) > 1 {
return Space{}, Warnings(warnings), actionerror.MultipleSpacesFoundError{OrgGUID: orgGUID, Name: spaceName}
}
return Space(ccv2Spaces[0]), Warnings(warnings), nil
} | |
c26086 | return actor.grantSpaceManagerByClientCredentials(orgGUID, spaceGUID, username)
}
return actor.grantSpaceManagerByUsername(orgGUID, spaceGUID, username)
} | |
c26087 |
warnings, err := actor.CloudControllerClient.UpdateSpaceDeveloper(spaceGUID, username)
return Warnings(warnings), err
}
warnings, err := actor.CloudControllerClient.UpdateSpaceDeveloperByUsername(spaceGUID, username)
return Warnings(warnings), err
} | |
c26088 | ccUser, ccWarnings, err := actor.CloudControllerClient.CreateUser(uaaUser.ID)
return User(ccUser), Warnings(ccWarnings), err
} | |
c26089 |
if location != nil {
wrappers = append(wrappers, wrapper.NewRequestLogger(ui.RequestLoggerFileWriter(location)))
}
authWrapper := wrapper.NewUAAAuthentication(uaaClient, config)
wrappers = append(wrappers, authWrapper)
wrappers = append(wrappers, wrapper.NewRetryRequest(config.RequestRetryCount()))
return c... | |
c26090 |
})
allWarnings = append(allWarnings, warnings...)
if err != nil {
return []ServicePlan{}, allWarnings, err
}
var plansToReturn []ServicePlan
for _, plan := range servicePlans {
plansToReturn = append(plansToReturn, ServicePlan(plan))
}
return plansToReturn, allWarnings, nil
} | |
c26091 | no transformation (== identity
// transform)
for i := range pt.transformer {
pt.transformer[i] = nop
}
if 0 < len(headers) {
pt.transformer[0] = TableContentHeaderColor
}
return pt
} | |
c26092 |
t.transformer[columnIndex] = tr
} | |
c26093 | append(t.rows, row)
} | |
c26094 | err != nil {
return err
}
}
fmt.Fprintf(result, "%s\n", trim(string(line.Bytes())))
return nil
}
// We have at least one multi-line cell in this row.
// Treat it a bit like a mini-table.
// Step I. Fill the mini-table. Note how it is stored
// column-major, not row-major.
// [column][row... | |
c26095 | cMS, derive a negative padding length from
// that, and subsequently return an error. What was
// further missing is trimming before entering the
// user-transform. Especially with color transforms
// any trailing space going in will not be removable
// for print.
//
// This happened for
// https://www... | |
c26096 | int, s string) string {
return HeaderColor(s)
} | |
c26097 | _, runeSize, err := r.ReadRune()
if err != nil {
return -1, fmt.Errorf("error when calculating visible size of: %s", s)
}
if runeSize == 3 {
size += 2 // Kanji and Katakana characters appear as double-width
} else {
size++
}
}
return size, nil
} | |
c26098 |
})
if err != nil {
return nil, err
}
var response cloudcontroller.Response
err = client.connection.Make(request, &response)
return response.Warnings, err
} | |
c26099 |
})
if err != nil {
return nil, err
}
response := cloudcontroller.Response{}
err = client.connection.Make(request, &response)
return response.Warnings, err
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.