upstream/packer
1
0
Fork 0
mirror of https://github.com/hashicorp/packer.git synced 2026-05-28 04:35:38 -04:00
Code Issues Projects Releases Packages Wiki Activity Actions 4

Merge pull request #9383 from GennadySpb/auth-by-sa-on-instance

Browse source 
Yandex: support authentication by Service Account on instance
This commit is contained in:
Megan Marsh 2020-06-17 12:03:30 -07:00 committed by GitHub
commit f92c52fc29
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
812 changed files with 148569 additions and 34559 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

41
builder/yandex/builder_acc_test.go
View file

@ -1,12 +1,17 @@
package yandex
import (
"fmt"
"os"
"testing"
"github.com/go-resty/resty/v2"
builderT "github.com/hashicorp/packer/helper/builder/testing"
)
const InstanceMetadataAddr = "169.254.169.254"
func TestBuilderAcc_basic(t *testing.T) {
builderT.Test(t, builderT.TestCase{
PreCheck: func() { testAccPreCheck(t) },
@ -15,6 +20,14 @@ func TestBuilderAcc_basic(t *testing.T) {
})
}
func TestBuilderAcc_instanceSA(t *testing.T) {
builderT.Test(t, builderT.TestCase{
PreCheck: func() { testAccPreCheckInstanceSA(t) },
Builder: &Builder{},
Template: testBuilderAccInstanceSA,
})
}
func testAccPreCheck(t *testing.T) {
if v := os.Getenv("YC_TOKEN"); v == "" {
t.Fatal("YC_TOKEN must be set for acceptance tests")
@ -24,6 +37,19 @@ func testAccPreCheck(t *testing.T) {
}
}
func testAccPreCheckInstanceSA(t *testing.T) {
client := resty.New()
_, err := client.R().SetHeader("Metadata-Flavor", "Google").Get(tokenUrl())
if err != nil {
t.Fatalf("error get Service Account token assignment: %s", err)
}
if v := os.Getenv("YC_FOLDER_ID"); v == "" {
t.Fatal("YC_FOLDER_ID must be set for acceptance tests")
}
}
const testBuilderAccBasic = `
{
"builders": [{
@ -34,3 +60,18 @@ const testBuilderAccBasic = `
}]
}
`
const testBuilderAccInstanceSA = `
{
"builders": [{
"type": "test",
"source_image_family": "ubuntu-1804-lts",
"use_ipv4_nat": "true",
"ssh_username": "ubuntu"
}]
}
`
func tokenUrl() string {
return fmt.Sprintf("http://%s/computeMetadata/v1/instance/service-accounts/default/token", InstanceMetadataAddr)
}

5
builder/yandex/config.go
View file

@ -248,11 +248,6 @@ func (c *Config) Prepare(raws ...interface{}) ([]string, error) {
c.FolderID = os.Getenv("YC_FOLDER_ID")
}
if c.Token == "" && c.ServiceAccountKeyFile == "" {
errs = packer.MultiErrorAppend(
errs, errors.New("a token or service account key file must be specified"))
}
if c.Token != "" && c.ServiceAccountKeyFile != "" {
errs = packer.MultiErrorAppend(
errs, errors.New("one of token or service account key file must be specified, not both"))

2
builder/yandex/config_test.go
View file

@ -9,7 +9,7 @@ import (
"github.com/stretchr/testify/require"
)
const TestServiceAccountKeyFile = "./test_data/fake-sa-key.json"
const TestServiceAccountKeyFile = "./testdata/fake-sa-key.json"
func TestConfigPrepare(t *testing.T) {
tf, err := ioutil.TempFile("", "packer")

6
builder/yandex/driver_yc.go
View file

@ -43,10 +43,16 @@ func NewDriverYC(ui packer.Ui, config *Config) (Driver, error) {
}
switch {
case config.Token == "" && config.ServiceAccountKeyFile == "":
log.Printf("[INFO] Use Instance Service Account for authentication")
sdkConfig.Credentials = ycsdk.InstanceServiceAccount()
case config.Token != "":
log.Printf("[INFO] Use OAuth token for authentication")
sdkConfig.Credentials = ycsdk.OAuthToken(config.Token)
case config.ServiceAccountKeyFile != "":
log.Printf("[INFO] Use Service Account key file %q for authentication", config.ServiceAccountKeyFile)
key, err := iamkey.ReadFromJSONFile(config.ServiceAccountKeyFile)
if err != nil {
return nil, err

0
builder/yandex/test_data/fake-sa-key.json → builder/yandex/testdata/fake-sa-key.json vendored
View file

82
builder/yandex/testdata/terraform/instanceSA.tf vendored Normal file
View file

@ -0,0 +1,82 @@
// This terraform code allows you to quickly create an instance with the assigned service account and the necessary rights.
// To start, it is required to specify two parameters: oauth token and folder id.
//
// $ terraform apply -var yc_token=<your_token_value> -var folder_id=<your_folder_id>
//
// After testing and completing work, just run the command to delete all provisioned cloud resources:
//
// $ terraform destroy -var yc_token=<your_token_value> -var folder_id=<your_folder_id>
//
// Variables section
variable "yc_token" {
description = "Yandex.Cloud OAuth token"
}
variable "folder_id" {
description = "Folder ID to provision all cloud resources"
}
variable "username" {
default = "ubuntu"
}
variable "path_to_ssh_public_key" {
default = "~/.ssh/id_rsa.pub"
}
// Provider section
provider "yandex" {
folder_id = var.folder_id
token = var.yc_token
zone = "ru-central1-a"
}
// Main section
data "yandex_compute_image" "ubuntu" {
family = "ubuntu-1604-lts"
}
resource "yandex_vpc_network" "this" {
}
resource "yandex_vpc_subnet" "this" {
network_id = yandex_vpc_network.this.id
v4_cidr_blocks = ["192.168.86.0/24"]
}
resource "yandex_compute_instance" "this" {
service_account_id = yandex_iam_service_account.this.id
boot_disk {
initialize_params {
image_id = data.yandex_compute_image.ubuntu.id
}
}
network_interface {
subnet_id = yandex_vpc_subnet.this.id
nat = true
}
resources {
cores = 1
memory = 1
core_fraction = 20
}
metadata = {
ssh-keys = "${var.username}:${file(var.path_to_ssh_public_key)}"
}
}
resource "yandex_iam_service_account" "this" {
name = "test-sa-for-instance"
}
resource "yandex_resourcemanager_folder_iam_member" "this" {
folder_id = var.folder_id
member = "serviceAccount:${yandex_iam_service_account.this.id}"
role = "editor"
}
// Output section
output "result" {
value = "\nuse ssh with login `ubuntu` to connect instance like:\n\n$ ssh -i ${var.path_to_ssh_public_key} -l ${var.username} ${yandex_compute_instance.this.network_interface[0].nat_ip_address}"
}

19
go.mod
View file

@ -26,7 +26,7 @@ require (
github.com/armon/go-metrics v0.0.0-20190430140413-ec5e00d3c878 // indirect
github.com/aws/aws-sdk-go v1.30.8
github.com/biogo/hts v0.0.0-20160420073057-50da7d4131a3
github.com/c2h5oh/datasize v0.0.0-20171227191756-4eba002a5eae
github.com/c2h5oh/datasize v0.0.0-20200112174442-28bbd4740fee
github.com/cheggaaa/pb v1.0.27
github.com/chzyer/readline v0.0.0-20180603132655-2972be24d48e
github.com/creack/goselect v0.1.0 // indirect
@ -41,15 +41,14 @@ require (
github.com/exoscale/egoscale v0.18.1
github.com/fatih/camelcase v1.0.0
github.com/fatih/structtag v1.0.0
github.com/ghodss/yaml v1.0.0 // indirect
github.com/go-ini/ini v1.25.4
github.com/go-ole/go-ole v1.2.4 // indirect
github.com/go-resty/resty/v2 v2.3.0 // indirect
github.com/go-resty/resty/v2 v2.3.0
github.com/gobwas/glob v0.2.3
github.com/gocolly/colly v1.2.0
github.com/gofrs/flock v0.7.1
github.com/golang-collections/collections v0.0.0-20130729185459-604e922904d3
github.com/golang/protobuf v1.3.5 // indirect
github.com/golang/protobuf v1.4.2 // indirect
github.com/google/go-cmp v0.4.0
github.com/google/go-querystring v1.0.0 // indirect
github.com/google/shlex v0.0.0-20150127133951-6f45313302b9
@ -139,8 +138,8 @@ require (
github.com/ulikunitz/xz v0.5.5
github.com/vmware/govmomi v0.22.2
github.com/xanzy/go-cloudstack v0.0.0-20190526095453-42f262b63ed0
github.com/yandex-cloud/go-genproto v0.0.0-20190916101622-7617782d381e
github.com/yandex-cloud/go-sdk v0.0.0-20190916101744-c781afa45829
github.com/yandex-cloud/go-genproto v0.0.0-20200608085315-d6e7ef5ceb97
github.com/yandex-cloud/go-sdk v0.0.0-20200610100221-ae86895efb97
github.com/zclconf/go-cty v1.4.0
github.com/zclconf/go-cty-yaml v1.0.1
golang.org/x/crypto v0.0.0-20200422194213-44a606286825
@ -148,13 +147,15 @@ require (
golang.org/x/net v0.0.0-20200602114024-627f9648deb9
golang.org/x/oauth2 v0.0.0-20200107190931-bf48bf16ab8d
golang.org/x/sync v0.0.0-20200317015054-43a5402ce75a
golang.org/x/sys v0.0.0-20200323222414-85ca7c5b95cd
golang.org/x/sys v0.0.0-20200615200032-f1bc736245b1
golang.org/x/text v0.3.3 // indirect
golang.org/x/tools v0.0.0-20200224181240-023911ca70b2
google.golang.org/api v0.21.0
google.golang.org/genproto v0.0.0-20200325114520-5b2d0af7952b // indirect
google.golang.org/grpc v1.28.0
google.golang.org/genproto v0.0.0-20200617032506-f1bdc9086088 // indirect
google.golang.org/grpc v1.29.1
gopkg.in/ini.v1 v1.42.0 // indirect
gopkg.in/jarcoal/httpmock.v1 v1.0.0-20181117152235-275e9df93516 // indirect
gopkg.in/yaml.v2 v2.3.0 // indirect
)
replace github.com/gofrs/flock => github.com/azr/flock v0.0.0-20190823144736-958d66434653

38
go.sum
View file

@ -138,6 +138,8 @@ github.com/bmatcuk/doublestar v1.1.5 h1:2bNwBOmhyFEFcoB3tGvTD5xanq+4kyOZlB8wFYbM
github.com/bmatcuk/doublestar v1.1.5/go.mod h1:wiQtGV+rzVYxB7WIlirSN++5HPtPlXEo9MEoZQC/PmE=
github.com/c2h5oh/datasize v0.0.0-20171227191756-4eba002a5eae h1:2Zmk+8cNvAGuY8AyvZuWpUdpQUAXwfom4ReVMe/CTIo=
github.com/c2h5oh/datasize v0.0.0-20171227191756-4eba002a5eae/go.mod h1:S/7n9copUssQ56c7aAgHqftWO4LTf4xY6CGWt8Bc+3M=
github.com/c2h5oh/datasize v0.0.0-20200112174442-28bbd4740fee h1:BnPxIde0gjtTnc9Er7cxvBk8DHLWhEux0SxayC8dP6I=
github.com/c2h5oh/datasize v0.0.0-20200112174442-28bbd4740fee/go.mod h1:S/7n9copUssQ56c7aAgHqftWO4LTf4xY6CGWt8Bc+3M=
github.com/census-instrumentation/opencensus-proto v0.2.1 h1:glEXhBS5PSLLv4IXzLA5yPRVX4bilULVyxxbrfOtDAk=
github.com/census-instrumentation/opencensus-proto v0.2.1/go.mod h1:f6KPmirojxKA12rnyqOA5BBL4O983OfeGPqjHWSTneU=
github.com/cheggaaa/pb v1.0.27 h1:wIkZHkNfC7R6GI5w7l/PdAdzXzlrbcI3p8OAlnkTsnc=
@ -248,6 +250,14 @@ github.com/golang/protobuf v1.3.2/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5y
github.com/golang/protobuf v1.3.3/go.mod h1:vzj43D7+SQXF/4pzW/hwtAqwc6iTitCiVSaWz5lYuqw=
github.com/golang/protobuf v1.3.5 h1:F768QJ1E9tib+q5Sc8MkdJi1RxLTbRcTf8LJV56aRls=
github.com/golang/protobuf v1.3.5/go.mod h1:6O5/vntMXwX2lRkT1hjjk0nAC1IDOTvTlVgjlRvqsdk=
github.com/golang/protobuf v1.4.0-rc.1/go.mod h1:ceaxUfeHdC40wWswd/P6IGgMaK3YpKi5j83Wpe3EHw8=
github.com/golang/protobuf v1.4.0-rc.1.0.20200221234624-67d41d38c208/go.mod h1:xKAWHe0F5eneWXFV3EuXVDTCmh+JuBKY0li0aMyXATA=
github.com/golang/protobuf v1.4.0-rc.2/go.mod h1:LlEzMj4AhA7rCAGe4KMBDvJI+AwstrUpVNzEA03Pprs=
github.com/golang/protobuf v1.4.0-rc.4.0.20200313231945-b860323f09d0/go.mod h1:WU3c8KckQ9AFe+yFwt9sWVRKCVIyN9cPHBJSNnbL67w=
github.com/golang/protobuf v1.4.0/go.mod h1:jodUvKwWbYaEsadDk5Fwe5c77LiNKVO9IDvqG2KuDX0=
github.com/golang/protobuf v1.4.1/go.mod h1:U8fpvMrcmy5pZrNK1lt4xCsGvpyWQ/VVv6QDs8UjoX8=
github.com/golang/protobuf v1.4.2 h1:+Z5KGCizgyZCbGh1KZqA0fcLLkwbsjIzS4aV2v7wJX0=
github.com/golang/protobuf v1.4.2/go.mod h1:oDoupMAO8OvCJWAcko0GGGIgR6R6ocIYbsSw735rRwI=
github.com/golang/snappy v0.0.1 h1:Qgr9rKW7uDUkrbSmQeiDsGa8SjGyCOGtuasMWwvp2P4=
github.com/golang/snappy v0.0.1/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q=
github.com/google/btree v0.0.0-20180813153112-4030bb1f1f0c h1:964Od4U6p2jUkFxvCydnIczKteheJEzHRToSGK3Bnlw=
@ -586,6 +596,7 @@ github.com/smartystreets/assertions v0.0.0-20180927180507-b2de0cb4f26d/go.mod h1
github.com/smartystreets/goconvey v0.0.0-20181108003508-044398e4856c h1:Ho+uVpkel/udgjbwB5Lktg9BtvJSh2DT0Hi6LPSyI2w=
github.com/smartystreets/goconvey v0.0.0-20181108003508-044398e4856c/go.mod h1:XDJAKZRPZ1CvBcN2aX5YOUTYGHki24fSF0Iv48Ibg0s=
github.com/spf13/pflag v1.0.2/go.mod h1:DYY7MBk1bdzusC3SYhjObp+wFpr4gzcvqqNjLnInEg4=
github.com/spf13/pflag v1.0.5/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg=
github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
github.com/stretchr/objx v0.1.1 h1:2vfRuCMp5sSVIDSqO8oNnWJq7mPa6KVP3iPIwFBuy8A=
github.com/stretchr/objx v0.1.1/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
@ -622,8 +633,12 @@ github.com/xanzy/go-cloudstack v0.0.0-20190526095453-42f262b63ed0 h1:NJrcIkdzq0C
github.com/xanzy/go-cloudstack v0.0.0-20190526095453-42f262b63ed0/go.mod h1:sBh287mCRwCz6zyXHMmw7sSZGPohVpnx+o+OY4M+i3A=
github.com/yandex-cloud/go-genproto v0.0.0-20190916101622-7617782d381e h1:hzwq5GUKP0aQzDja1XP4sBYyOmnezs/RVtzP+xiLbfI=
github.com/yandex-cloud/go-genproto v0.0.0-20190916101622-7617782d381e/go.mod h1:HEUYX/p8966tMUHHT+TsS0hF/Ca/NYwqprC5WXSDMfE=
github.com/yandex-cloud/go-genproto v0.0.0-20200608085315-d6e7ef5ceb97 h1:DoqSUxQkBLislVgA1qkM0u7g04It4VRMidyLBH/O/as=
github.com/yandex-cloud/go-genproto v0.0.0-20200608085315-d6e7ef5ceb97/go.mod h1:HEUYX/p8966tMUHHT+TsS0hF/Ca/NYwqprC5WXSDMfE=
github.com/yandex-cloud/go-sdk v0.0.0-20190916101744-c781afa45829 h1:2FGwbx03GpP1Ulzg/L46tSoKh9t4yg8BhMKQl/Ff1x8=
github.com/yandex-cloud/go-sdk v0.0.0-20190916101744-c781afa45829/go.mod h1:Eml0jFLU4VVHgIN8zPHMuNwZXVzUMILyO6lQZSfz854=
github.com/yandex-cloud/go-sdk v0.0.0-20200610100221-ae86895efb97 h1:8KwSw9xtQBeyeX1EpOlOjRc0JaHlh8B8GglKA6iXt08=
github.com/yandex-cloud/go-sdk v0.0.0-20200610100221-ae86895efb97/go.mod h1:3p2xVpQrHyPxV4UCKnKozt9n+g1LRENOQ33CH8rqLnY=
github.com/zclconf/go-cty v1.0.0/go.mod h1:xnAOWiHeOqg2nWS62VtQ7pbOu17FtxJNW8RLEih+O3s=
github.com/zclconf/go-cty v1.2.0/go.mod h1:hOPWgoHbaTUnI5k4D2ld+GRpFJSCe6bCM7m1q/N4PQ8=
github.com/zclconf/go-cty v1.4.0 h1:+q+tmgyUB94HIdH/uVTIi/+kt3pt4sHwEZAcTyLoGsQ=
@ -719,6 +734,7 @@ golang.org/x/net v0.0.0-20191209160850-c0dbc17a3553/go.mod h1:z5CRVTTTmAJ677TzLL
golang.org/x/net v0.0.0-20200114155413-6afb5195e5aa/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
golang.org/x/net v0.0.0-20200202094626-16171245cfb2/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
golang.org/x/net v0.0.0-20200222125558-5a598a2470a0/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
golang.org/x/net v0.0.0-20200320220750-118fecf932d8/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
golang.org/x/net v0.0.0-20200513185701-a91f0712d120/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A=
golang.org/x/net v0.0.0-20200602114024-627f9648deb9 h1:pNX+40auqi2JqRfOP1akLGtYcn15TUbkhwuCO3foqqM=
golang.org/x/net v0.0.0-20200602114024-627f9648deb9/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A=
@ -779,6 +795,8 @@ golang.org/x/sys v0.0.0-20200212091648-12a6c2dcc1e4/go.mod h1:h1NjWce9XRLGQEsW7w
golang.org/x/sys v0.0.0-20200223170610-d5e6a3e2c0ae/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20200323222414-85ca7c5b95cd h1:xhmwyvizuTgC2qz7ZlMluP20uW+C3Rm0FD/WLDX8884=
golang.org/x/sys v0.0.0-20200323222414-85ca7c5b95cd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20200615200032-f1bc736245b1 h1:ogLJMz+qpzav7lGMh10LMvAkM/fAoGlaiiHYiFYdm80=
golang.org/x/sys v0.0.0-20200615200032-f1bc736245b1/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/text v0.0.0-20170915032832-14c0d48ead0c/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
golang.org/x/text v0.3.0 h1:g61tztE5qeGQ89tm6NTjjM9VPIm088od1l6aSorWRWg=
golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
@ -787,6 +805,8 @@ golang.org/x/text v0.3.1-0.20180807135948-17ff2d5776d2/go.mod h1:NqM8EUOU14njkJ3
golang.org/x/text v0.3.1-0.20181227161524-e6919f6577db/go.mod h1:bEr9sfX3Q8Zfm5fL9x+3itogRgK3+ptLWKqgva+5dAk=
golang.org/x/text v0.3.2 h1:tW2bmiBqwgJj/UpqtC8EpXEZVYOwU0yG4iWbprSVAcs=
golang.org/x/text v0.3.2/go.mod h1:bEr9sfX3Q8Zfm5fL9x+3itogRgK3+ptLWKqgva+5dAk=
golang.org/x/text v0.3.3 h1:cokOdA+Jmi5PJGXLlLllQSgYigAEfHXJAERHVMaCc2k=
golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
golang.org/x/time v0.0.0-20181108054448-85acf8d2951c h1:fqgJT0MGcGpPgpWU7VRdRjuArfcOvC4AoJmILihzhDg=
golang.org/x/time v0.0.0-20181108054448-85acf8d2951c/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
golang.org/x/time v0.0.0-20190308202827-9d24e82272b4 h1:SvFZT6jyqRaOeXpc5h/JSfZenJ2O330aBsf7JfSUXmQ=
@ -876,8 +896,12 @@ google.golang.org/genproto v0.0.0-20200122232147-0452cf42e150/go.mod h1:n3cpQtvx
google.golang.org/genproto v0.0.0-20200204135345-fa8e72b47b90/go.mod h1:GmwEX6Z4W5gMy59cAlVYjN9JhxgbQH6Gn+gFDQe2lzA=
google.golang.org/genproto v0.0.0-20200212174721-66ed5ce911ce/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c=
google.golang.org/genproto v0.0.0-20200224152610-e50cd9704f63/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c=
google.golang.org/genproto v0.0.0-20200323114720-3f67cca34472/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c=
google.golang.org/genproto v0.0.0-20200325114520-5b2d0af7952b h1:j5eujPLMak6H9l2EM381rW9X47/HPUyESXWJW9lVSsQ=
google.golang.org/genproto v0.0.0-20200325114520-5b2d0af7952b/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c=
google.golang.org/genproto v0.0.0-20200526211855-cb27e3aa2013/go.mod h1:NbSheEEYHJ7i3ixzK3sjbqSGDJWnxyFXZblF3eUsNvo=
google.golang.org/genproto v0.0.0-20200617032506-f1bdc9086088 h1:XXo4PvhJkaWYIkwn7bX7mcdB8RdcOvn12HbaUUAwX3E=
google.golang.org/genproto v0.0.0-20200617032506-f1bdc9086088/go.mod h1:jDfRM7FcilCzHH/e9qn6dsT145K34l5v+OpcnNgKAAA=
google.golang.org/grpc v1.14.0/go.mod h1:yo6s7OP7yaDglbqo1J04qKzAhqBH6lvTonzMVmEdcZw=
google.golang.org/grpc v1.19.0/go.mod h1:mqu4LbDTu4XGKhr4mRzUsmM4RtVoemTSY81AxZiDr8c=
google.golang.org/grpc v1.20.1 h1:Hz2g2wirWK7H0qIIhGIqRGTuMwTE8HEKFnDZZ7lm9NU=
@ -893,6 +917,18 @@ google.golang.org/grpc v1.27.0/go.mod h1:qbnxyOmOxrQa7FizSgH+ReBfzJrCY1pSN7KXBS8
google.golang.org/grpc v1.27.1/go.mod h1:qbnxyOmOxrQa7FizSgH+ReBfzJrCY1pSN7KXBS8abTk=
google.golang.org/grpc v1.28.0 h1:bO/TA4OxCOummhSf10siHuG7vJOiwh7SpRpFZDkOgl4=
google.golang.org/grpc v1.28.0/go.mod h1:rpkK4SK4GF4Ach/+MFLZUBavHOvF2JJB5uozKKal+60=
google.golang.org/grpc v1.29.1 h1:EC2SB8S04d2r73uptxphDSUG+kTKVgjRPF+N3xpxRB4=
google.golang.org/grpc v1.29.1/go.mod h1:itym6AZVZYACWQqET3MqgPpjcuV5QH3BxFS3IjizoKk=
google.golang.org/protobuf v0.0.0-20200109180630-ec00e32a8dfd/go.mod h1:DFci5gLYBciE7Vtevhsrf46CRTquxDuWsQurQQe4oz8=
google.golang.org/protobuf v0.0.0-20200221191635-4d8936d0db64/go.mod h1:kwYJMbMJ01Woi6D6+Kah6886xMZcty6N08ah7+eCXa0=
google.golang.org/protobuf v0.0.0-20200228230310-ab0ca4ff8a60/go.mod h1:cfTl7dwQJ+fmap5saPgwCLgHXTUD7jkjRqWcaiX5VyM=
google.golang.org/protobuf v1.20.1-0.20200309200217-e05f789c0967/go.mod h1:A+miEFZTKqfCUM6K7xSMQL9OKL/b6hQv+e19PK+JZNE=
google.golang.org/protobuf v1.21.0/go.mod h1:47Nbq4nVaFHyn7ilMalzfO3qCViNmqZ2kzikPIcrTAo=
google.golang.org/protobuf v1.22.0/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU=
google.golang.org/protobuf v1.23.0/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU=
google.golang.org/protobuf v1.23.1-0.20200526195155-81db48ad09cc/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU=
google.golang.org/protobuf v1.24.0 h1:UhZDfRO8JRQru4/+LlLE0BRKGF8L+PICnvYZmx/fEGA=
google.golang.org/protobuf v1.24.0/go.mod h1:r/3tXBNzIEhYS9I1OUVjXDlt8tc493IdKGjtUeSXeh4=
gopkg.in/asn1-ber.v1 v1.0.0-20181015200546-f715ec2f112d/go.mod h1:cuepJuh7vyXfUyUwEgHQXw849cJrilpS5NeIjOWESAw=
gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM=
gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
@ -914,6 +950,8 @@ gopkg.in/yaml.v2 v2.2.2 h1:ZCJp+EgiOT7lHqUV2J862kp8Qj64Jo6az82+3Td9dZw=
gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
gopkg.in/yaml.v2 v2.2.8 h1:obN1ZagJSUGI0Ek/LBmuj4SNLPfIny3KsKFopxRdj10=
gopkg.in/yaml.v2 v2.2.8/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
gopkg.in/yaml.v2 v2.3.0 h1:clyUAQHOM3G0M3f5vQj7LuJrETvjVot3Z5el9nffUtU=
gopkg.in/yaml.v2 v2.3.0/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
honnef.co/go/tools v0.0.0-20190102054323-c2f93a96b099/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=
honnef.co/go/tools v0.0.0-20190106161140-3f1c8253044a/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=
honnef.co/go/tools v0.0.0-20190418001031-e561f6794a2a/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=

5
post-processor/yandex-export/post-processor.go
View file

@ -88,11 +88,6 @@ func (p *PostProcessor) Configure(raws ...interface{}) error {
p.config.ServiceAccountKeyFile = os.Getenv("YC_SERVICE_ACCOUNT_KEY_FILE")
}
if p.config.Token == "" && p.config.ServiceAccountKeyFile == "" {
errs = packer.MultiErrorAppend(
errs, fmt.Errorf("a token or service account key file must be specified"))
}
if p.config.Token != "" && p.config.ServiceAccountKeyFile != "" {
errs = packer.MultiErrorAppend(
errs, fmt.Errorf("one of token or service account key file must be specified, not both"))

2
post-processor/yandex-export/post-processor_test.go
View file

@ -28,7 +28,7 @@ func TestPostProcessor_Configure(t *testing.T) {
ServiceAccountKeyFile: "",
},
},
wantErr: true,
wantErr: false,
},
{
name: "both token and sa key file",

3
vendor/github.com/c2h5oh/datasize/.travis.yml generated vendored
View file

@ -5,6 +5,9 @@ go:
- 1.4
- 1.5
- 1.6
- 1.7
- 1.8
- 1.9
- tip
script:

27
vendor/github.com/c2h5oh/datasize/README.md generated vendored
View file

@ -2,9 +2,10 @@
Golang helpers for data sizes
### Constants
Just like `time` package provides `time.Second`, `time.Day` constants `datasize` provides:
* `datasize.B` 1 byte
* `datasize.KB` 1 kilobyte
* `datasize.MB` 1 megabyte
@ -14,7 +15,9 @@ Just like `time` package provides `time.Second`, `time.Day` constants `datasize`
* `datasize.EB` 1 exabyte
### Helpers
Just like `time` package provides `duration.Nanoseconds() uint64 `, `duration.Hours() float64` helpers `datasize` has
Just like `time` package provides `duration.Nanoseconds() uint64 `, `duration.Hours() float64` helpers `datasize` has.
* `ByteSize.Bytes() uint64`
* `ByteSize.Kilobytes() float4`
* `ByteSize.Megabytes() float64`
@ -26,7 +29,9 @@ Just like `time` package provides `duration.Nanoseconds() uint64 `, `duration.Ho
Warning: see limitations at the end of this document about a possible precission loss
### Parsing strings
`datasize.ByteSize` implements `TextUnmarshaler` interface and will automatically parse human readable strings into correct values where it is used:
* `"10 MB"` -> `10* datasize.MB`
* `"10240 g"` -> `10 * datasize.TB`
* `"2000"` -> `2000 * datasize.B`
@ -36,28 +41,34 @@ Warning: see limitations at the end of this document about a possible precission
* `"1 gigabyte"` -> `1 * datasize.GB`
You can also do it manually:
```go
var v datasize.ByteSize
err := v.UnmarshalText([]byte("100 mb"))
```
### Printing
`Bytesize.String()` uses largest unit allowing an integer value:
* `(102400 * datasize.MB).String()` -> `"100GB"`
* `(datasize.MB + datasize.KB).String()` -> `"1025KB"`
Use `%d` format string to get value in bytes without a unit
`Bytesize.String()` uses largest unit allowing an integer value:
* `(102400 * datasize.MB).String()` -> `"100GB"`
* `(datasize.MB + datasize.KB).String()` -> `"1025KB"`
Use `%d` format string to get value in bytes without a unit.
### JSON and other encoding
Both `TextMarshaler` and `TextUnmarshaler` interfaces are implemented - JSON will just work. Other encoders will work provided they use those interfaces.
### Human readable
`ByteSize.HumanReadable()` or `ByteSize.HR()` returns a string with 1-3 digits, followed by 1 decimal place, a space and unit big enough to get 1-3 digits
* `(102400 * datasize.MB).String()` -> `"100.0 GB"`
* `(datasize.MB + 512 * datasize.KB).String()` -> `"1.5 MB"`
* `(102400 * datasize.MB).String()` -> `"100.0 GB"`
* `(datasize.MB + 512 * datasize.KB).String()` -> `"1.5 MB"`
### Limitations
* The underlying data type for `data.ByteSize` is `uint64`, so values outside of 0 to 2^64-1 range will overflow
* size helper functions (like `ByteSize.Kilobytes()`) return `float64`, which can't represent all possible values of `uint64` accurately:
* if the returned value is supposed to have no fraction (ie `(10 * datasize.MB).Kilobytes()`) accuracy loss happens when value is more than 2^53 larger than unit: `.Kilobytes()` over 8 petabytes, `.Megabytes()` over 8 exabytes

398
vendor/github.com/golang/protobuf/internal/gengogrpc/grpc.go generated vendored Normal file
View file

@ -0,0 +1,398 @@
// Copyright 2018 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
// Package gengogrpc contains the gRPC code generator.
package gengogrpc
import (
"fmt"
"strconv"
"strings"
"google.golang.org/protobuf/compiler/protogen"
"google.golang.org/protobuf/types/descriptorpb"
)
const (
contextPackage = protogen.GoImportPath("context")
grpcPackage = protogen.GoImportPath("google.golang.org/grpc")
codesPackage = protogen.GoImportPath("google.golang.org/grpc/codes")
statusPackage = protogen.GoImportPath("google.golang.org/grpc/status")
)
// GenerateFile generates a _grpc.pb.go file containing gRPC service definitions.
func GenerateFile(gen *protogen.Plugin, file *protogen.File) *protogen.GeneratedFile {
if len(file.Services) == 0 {
return nil
}
filename := file.GeneratedFilenamePrefix + "_grpc.pb.go"
g := gen.NewGeneratedFile(filename, file.GoImportPath)
g.P("// Code generated by protoc-gen-go-grpc. DO NOT EDIT.")
g.P()
g.P("package ", file.GoPackageName)
g.P()
GenerateFileContent(gen, file, g)
return g
}
// GenerateFileContent generates the gRPC service definitions, excluding the package statement.
func GenerateFileContent(gen *protogen.Plugin, file *protogen.File, g *protogen.GeneratedFile) {
if len(file.Services) == 0 {
return
}
// TODO: Remove this. We don't need to include these references any more.
g.P("// Reference imports to suppress errors if they are not otherwise used.")
g.P("var _ ", contextPackage.Ident("Context"))
g.P("var _ ", grpcPackage.Ident("ClientConnInterface"))
g.P()
g.P("// This is a compile-time assertion to ensure that this generated file")
g.P("// is compatible with the grpc package it is being compiled against.")
g.P("const _ = ", grpcPackage.Ident("SupportPackageIsVersion6"))
g.P()
for _, service := range file.Services {
genService(gen, file, g, service)
}
}
func genService(gen *protogen.Plugin, file *protogen.File, g *protogen.GeneratedFile, service *protogen.Service) {
clientName := service.GoName + "Client"
g.P("// ", clientName, " is the client API for ", service.GoName, " service.")
g.P("//")
g.P("// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.")
// Client interface.
if service.Desc.Options().(*descriptorpb.ServiceOptions).GetDeprecated() {
g.P("//")
g.P(deprecationComment)
}
g.Annotate(clientName, service.Location)
g.P("type ", clientName, " interface {")
for _, method := range service.Methods {
g.Annotate(clientName+"."+method.GoName, method.Location)
if method.Desc.Options().(*descriptorpb.MethodOptions).GetDeprecated() {
g.P(deprecationComment)
}
g.P(method.Comments.Leading,
clientSignature(g, method))
}
g.P("}")
g.P()
// Client structure.
g.P("type ", unexport(clientName), " struct {")
g.P("cc ", grpcPackage.Ident("ClientConnInterface"))
g.P("}")
g.P()
// NewClient factory.
if service.Desc.Options().(*descriptorpb.ServiceOptions).GetDeprecated() {
g.P(deprecationComment)
}
g.P("func New", clientName, " (cc ", grpcPackage.Ident("ClientConnInterface"), ") ", clientName, " {")
g.P("return &", unexport(clientName), "{cc}")
g.P("}")
g.P()
var methodIndex, streamIndex int
// Client method implementations.
for _, method := range service.Methods {
if !method.Desc.IsStreamingServer() && !method.Desc.IsStreamingClient() {
// Unary RPC method
genClientMethod(gen, file, g, method, methodIndex)
methodIndex++
} else {
// Streaming RPC method
genClientMethod(gen, file, g, method, streamIndex)
streamIndex++
}
}
// Server interface.
serverType := service.GoName + "Server"
g.P("// ", serverType, " is the server API for ", service.GoName, " service.")
if service.Desc.Options().(*descriptorpb.ServiceOptions).GetDeprecated() {
g.P("//")
g.P(deprecationComment)
}
g.Annotate(serverType, service.Location)
g.P("type ", serverType, " interface {")
for _, method := range service.Methods {
g.Annotate(serverType+"."+method.GoName, method.Location)
if method.Desc.Options().(*descriptorpb.MethodOptions).GetDeprecated() {
g.P(deprecationComment)
}
g.P(method.Comments.Leading,
serverSignature(g, method))
}
g.P("}")
g.P()
// Server Unimplemented struct for forward compatibility.
g.P("// Unimplemented", serverType, " can be embedded to have forward compatible implementations.")
g.P("type Unimplemented", serverType, " struct {")
g.P("}")
g.P()
for _, method := range service.Methods {
nilArg := ""
if !method.Desc.IsStreamingClient() && !method.Desc.IsStreamingServer() {
nilArg = "nil,"
}
g.P("func (*Unimplemented", serverType, ") ", serverSignature(g, method), "{")
g.P("return ", nilArg, statusPackage.Ident("Errorf"), "(", codesPackage.Ident("Unimplemented"), `, "method `, method.GoName, ` not implemented")`)
g.P("}")
}
g.P()
// Server registration.
if service.Desc.Options().(*descriptorpb.ServiceOptions).GetDeprecated() {
g.P(deprecationComment)
}
serviceDescVar := "_" + service.GoName + "_serviceDesc"
g.P("func Register", service.GoName, "Server(s *", grpcPackage.Ident("Server"), ", srv ", serverType, ") {")
g.P("s.RegisterService(&", serviceDescVar, `, srv)`)
g.P("}")
g.P()
// Server handler implementations.
var handlerNames []string
for _, method := range service.Methods {
hname := genServerMethod(gen, file, g, method)
handlerNames = append(handlerNames, hname)
}
// Service descriptor.
g.P("var ", serviceDescVar, " = ", grpcPackage.Ident("ServiceDesc"), " {")
g.P("ServiceName: ", strconv.Quote(string(service.Desc.FullName())), ",")
g.P("HandlerType: (*", serverType, ")(nil),")
g.P("Methods: []", grpcPackage.Ident("MethodDesc"), "{")
for i, method := range service.Methods {
if method.Desc.IsStreamingClient() || method.Desc.IsStreamingServer() {
continue
}
g.P("{")
g.P("MethodName: ", strconv.Quote(string(method.Desc.Name())), ",")
g.P("Handler: ", handlerNames[i], ",")
g.P("},")
}
g.P("},")
g.P("Streams: []", grpcPackage.Ident("StreamDesc"), "{")
for i, method := range service.Methods {
if !method.Desc.IsStreamingClient() && !method.Desc.IsStreamingServer() {
continue
}
g.P("{")
g.P("StreamName: ", strconv.Quote(string(method.Desc.Name())), ",")
g.P("Handler: ", handlerNames[i], ",")
if method.Desc.IsStreamingServer() {
g.P("ServerStreams: true,")
}
if method.Desc.IsStreamingClient() {
g.P("ClientStreams: true,")
}
g.P("},")
}
g.P("},")
g.P("Metadata: \"", file.Desc.Path(), "\",")
g.P("}")
g.P()
}
func clientSignature(g *protogen.GeneratedFile, method *protogen.Method) string {
s := method.GoName + "(ctx " + g.QualifiedGoIdent(contextPackage.Ident("Context"))
if !method.Desc.IsStreamingClient() {
s += ", in *" + g.QualifiedGoIdent(method.Input.GoIdent)
}
s += ", opts ..." + g.QualifiedGoIdent(grpcPackage.Ident("CallOption")) + ") ("
if !method.Desc.IsStreamingClient() && !method.Desc.IsStreamingServer() {
s += "*" + g.QualifiedGoIdent(method.Output.GoIdent)
} else {
s += method.Parent.GoName + "_" + method.GoName + "Client"
}
s += ", error)"
return s
}
func genClientMethod(gen *protogen.Plugin, file *protogen.File, g *protogen.GeneratedFile, method *protogen.Method, index int) {
service := method.Parent
sname := fmt.Sprintf("/%s/%s", service.Desc.FullName(), method.Desc.Name())
if method.Desc.Options().(*descriptorpb.MethodOptions).GetDeprecated() {
g.P(deprecationComment)
}
g.P("func (c *", unexport(service.GoName), "Client) ", clientSignature(g, method), "{")
if !method.Desc.IsStreamingServer() && !method.Desc.IsStreamingClient() {
g.P("out := new(", method.Output.GoIdent, ")")
g.P(`err := c.cc.Invoke(ctx, "`, sname, `", in, out, opts...)`)
g.P("if err != nil { return nil, err }")
g.P("return out, nil")
g.P("}")
g.P()
return
}
streamType := unexport(service.GoName) + method.GoName + "Client"
serviceDescVar := "_" + service.GoName + "_serviceDesc"
g.P("stream, err := c.cc.NewStream(ctx, &", serviceDescVar, ".Streams[", index, `], "`, sname, `", opts...)`)
g.P("if err != nil { return nil, err }")
g.P("x := &", streamType, "{stream}")
if !method.Desc.IsStreamingClient() {
g.P("if err := x.ClientStream.SendMsg(in); err != nil { return nil, err }")
g.P("if err := x.ClientStream.CloseSend(); err != nil { return nil, err }")
}
g.P("return x, nil")
g.P("}")
g.P()
genSend := method.Desc.IsStreamingClient()
genRecv := method.Desc.IsStreamingServer()
genCloseAndRecv := !method.Desc.IsStreamingServer()
// Stream auxiliary types and methods.
g.P("type ", service.GoName, "_", method.GoName, "Client interface {")
if genSend {
g.P("Send(*", method.Input.GoIdent, ") error")
}
if genRecv {
g.P("Recv() (*", method.Output.GoIdent, ", error)")
}
if genCloseAndRecv {
g.P("CloseAndRecv() (*", method.Output.GoIdent, ", error)")
}
g.P(grpcPackage.Ident("ClientStream"))
g.P("}")
g.P()
g.P("type ", streamType, " struct {")
g.P(grpcPackage.Ident("ClientStream"))
g.P("}")
g.P()
if genSend {
g.P("func (x *", streamType, ") Send(m *", method.Input.GoIdent, ") error {")
g.P("return x.ClientStream.SendMsg(m)")
g.P("}")
g.P()
}
if genRecv {
g.P("func (x *", streamType, ") Recv() (*", method.Output.GoIdent, ", error) {")
g.P("m := new(", method.Output.GoIdent, ")")
g.P("if err := x.ClientStream.RecvMsg(m); err != nil { return nil, err }")
g.P("return m, nil")
g.P("}")
g.P()
}
if genCloseAndRecv {
g.P("func (x *", streamType, ") CloseAndRecv() (*", method.Output.GoIdent, ", error) {")
g.P("if err := x.ClientStream.CloseSend(); err != nil { return nil, err }")
g.P("m := new(", method.Output.GoIdent, ")")
g.P("if err := x.ClientStream.RecvMsg(m); err != nil { return nil, err }")
g.P("return m, nil")
g.P("}")
g.P()
}
}
func serverSignature(g *protogen.GeneratedFile, method *protogen.Method) string {
var reqArgs []string
ret := "error"
if !method.Desc.IsStreamingClient() && !method.Desc.IsStreamingServer() {
reqArgs = append(reqArgs, g.QualifiedGoIdent(contextPackage.Ident("Context")))
ret = "(*" + g.QualifiedGoIdent(method.Output.GoIdent) + ", error)"
}
if !method.Desc.IsStreamingClient() {
reqArgs = append(reqArgs, "*"+g.QualifiedGoIdent(method.Input.GoIdent))
}
if method.Desc.IsStreamingClient() || method.Desc.IsStreamingServer() {
reqArgs = append(reqArgs, method.Parent.GoName+"_"+method.GoName+"Server")
}
return method.GoName + "(" + strings.Join(reqArgs, ", ") + ") " + ret
}
func genServerMethod(gen *protogen.Plugin, file *protogen.File, g *protogen.GeneratedFile, method *protogen.Method) string {
service := method.Parent
hname := fmt.Sprintf("_%s_%s_Handler", service.GoName, method.GoName)
if !method.Desc.IsStreamingClient() && !method.Desc.IsStreamingServer() {
g.P("func ", hname, "(srv interface{}, ctx ", contextPackage.Ident("Context"), ", dec func(interface{}) error, interceptor ", grpcPackage.Ident("UnaryServerInterceptor"), ") (interface{}, error) {")
g.P("in := new(", method.Input.GoIdent, ")")
g.P("if err := dec(in); err != nil { return nil, err }")
g.P("if interceptor == nil { return srv.(", service.GoName, "Server).", method.GoName, "(ctx, in) }")
g.P("info := &", grpcPackage.Ident("UnaryServerInfo"), "{")
g.P("Server: srv,")
g.P("FullMethod: ", strconv.Quote(fmt.Sprintf("/%s/%s", service.Desc.FullName(), method.GoName)), ",")
g.P("}")
g.P("handler := func(ctx ", contextPackage.Ident("Context"), ", req interface{}) (interface{}, error) {")
g.P("return srv.(", service.GoName, "Server).", method.GoName, "(ctx, req.(*", method.Input.GoIdent, "))")
g.P("}")
g.P("return interceptor(ctx, in, info, handler)")
g.P("}")
g.P()
return hname
}
streamType := unexport(service.GoName) + method.GoName + "Server"
g.P("func ", hname, "(srv interface{}, stream ", grpcPackage.Ident("ServerStream"), ") error {")
if !method.Desc.IsStreamingClient() {
g.P("m := new(", method.Input.GoIdent, ")")
g.P("if err := stream.RecvMsg(m); err != nil { return err }")
g.P("return srv.(", service.GoName, "Server).", method.GoName, "(m, &", streamType, "{stream})")
} else {
g.P("return srv.(", service.GoName, "Server).", method.GoName, "(&", streamType, "{stream})")
}
g.P("}")
g.P()
genSend := method.Desc.IsStreamingServer()
genSendAndClose := !method.Desc.IsStreamingServer()
genRecv := method.Desc.IsStreamingClient()
// Stream auxiliary types and methods.
g.P("type ", service.GoName, "_", method.GoName, "Server interface {")
if genSend {
g.P("Send(*", method.Output.GoIdent, ") error")
}
if genSendAndClose {
g.P("SendAndClose(*", method.Output.GoIdent, ") error")
}
if genRecv {
g.P("Recv() (*", method.Input.GoIdent, ", error)")
}
g.P(grpcPackage.Ident("ServerStream"))
g.P("}")
g.P()
g.P("type ", streamType, " struct {")
g.P(grpcPackage.Ident("ServerStream"))
g.P("}")
g.P()
if genSend {
g.P("func (x *", streamType, ") Send(m *", method.Output.GoIdent, ") error {")
g.P("return x.ServerStream.SendMsg(m)")
g.P("}")
g.P()
}
if genSendAndClose {
g.P("func (x *", streamType, ") SendAndClose(m *", method.Output.GoIdent, ") error {")
g.P("return x.ServerStream.SendMsg(m)")
g.P("}")
g.P()
}
if genRecv {
g.P("func (x *", streamType, ") Recv() (*", method.Input.GoIdent, ", error) {")
g.P("m := new(", method.Input.GoIdent, ")")
g.P("if err := x.ServerStream.RecvMsg(m); err != nil { return nil, err }")
g.P("return m, nil")
g.P("}")
g.P()
}
return hname
}
const deprecationComment = "// Deprecated: Do not use."
func unexport(s string) string { return strings.ToLower(s[:1]) + s[1:] }

514
vendor/github.com/golang/protobuf/jsonpb/decode.go generated vendored Normal file
View file

@ -0,0 +1,514 @@
// Copyright 2015 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
package jsonpb
import (
"encoding/json"
"errors"
"fmt"
"io"
"math"
"reflect"
"strconv"
"strings"
"time"
"github.com/golang/protobuf/proto"
"google.golang.org/protobuf/encoding/protojson"
protoV2 "google.golang.org/protobuf/proto"
"google.golang.org/protobuf/reflect/protoreflect"
"google.golang.org/protobuf/reflect/protoregistry"
)
const wrapJSONUnmarshalV2 = false
// UnmarshalNext unmarshals the next JSON object from d into m.
func UnmarshalNext(d *json.Decoder, m proto.Message) error {
return new(Unmarshaler).UnmarshalNext(d, m)
}
// Unmarshal unmarshals a JSON object from r into m.
func Unmarshal(r io.Reader, m proto.Message) error {
return new(Unmarshaler).Unmarshal(r, m)
}
// UnmarshalString unmarshals a JSON object from s into m.
func UnmarshalString(s string, m proto.Message) error {
return new(Unmarshaler).Unmarshal(strings.NewReader(s), m)
}
// Unmarshaler is a configurable object for converting from a JSON
// representation to a protocol buffer object.
type Unmarshaler struct {
// AllowUnknownFields specifies whether to allow messages to contain
// unknown JSON fields, as opposed to failing to unmarshal.
AllowUnknownFields bool
// AnyResolver is used to resolve the google.protobuf.Any well-known type.
// If unset, the global registry is used by default.
AnyResolver AnyResolver
}
// JSONPBUnmarshaler is implemented by protobuf messages that customize the way
// they are unmarshaled from JSON. Messages that implement this should also
// implement JSONPBMarshaler so that the custom format can be produced.
//
// The JSON unmarshaling must follow the JSON to proto specification:
// https://developers.google.com/protocol-buffers/docs/proto3#json
//
// Deprecated: Custom types should implement protobuf reflection instead.
type JSONPBUnmarshaler interface {
UnmarshalJSONPB(*Unmarshaler, []byte) error
}
// Unmarshal unmarshals a JSON object from r into m.
func (u *Unmarshaler) Unmarshal(r io.Reader, m proto.Message) error {
return u.UnmarshalNext(json.NewDecoder(r), m)
}
// UnmarshalNext unmarshals the next JSON object from d into m.
func (u *Unmarshaler) UnmarshalNext(d *json.Decoder, m proto.Message) error {
if m == nil {
return errors.New("invalid nil message")
}
// Parse the next JSON object from the stream.
raw := json.RawMessage{}
if err := d.Decode(&raw); err != nil {
return err
}
// Check for custom unmarshalers first since they may not properly
// implement protobuf reflection that the logic below relies on.
if jsu, ok := m.(JSONPBUnmarshaler); ok {
return jsu.UnmarshalJSONPB(u, raw)
}
mr := proto.MessageReflect(m)
// NOTE: For historical reasons, a top-level null is treated as a noop.
// This is incorrect, but kept for compatibility.
if string(raw) == "null" && mr.Descriptor().FullName() != "google.protobuf.Value" {
return nil
}
if wrapJSONUnmarshalV2 {
// NOTE: If input message is non-empty, we need to preserve merge semantics
// of the old jsonpb implementation. These semantics are not supported by
// the protobuf JSON specification.
isEmpty := true
mr.Range(func(protoreflect.FieldDescriptor, protoreflect.Value) bool {
isEmpty = false // at least one iteration implies non-empty
return false
})
if !isEmpty {
// Perform unmarshaling into a newly allocated, empty message.
mr = mr.New()
// Use a defer to copy all unmarshaled fields into the original message.
dst := proto.MessageReflect(m)
defer mr.Range(func(fd protoreflect.FieldDescriptor, v protoreflect.Value) bool {
dst.Set(fd, v)
return true
})
}
// Unmarshal using the v2 JSON unmarshaler.
opts := protojson.UnmarshalOptions{
DiscardUnknown: u.AllowUnknownFields,
}
if u.AnyResolver != nil {
opts.Resolver = anyResolver{u.AnyResolver}
}
return opts.Unmarshal(raw, mr.Interface())
} else {
if err := u.unmarshalMessage(mr, raw); err != nil {
return err
}
return protoV2.CheckInitialized(mr.Interface())
}
}
func (u *Unmarshaler) unmarshalMessage(m protoreflect.Message, in []byte) error {
md := m.Descriptor()
fds := md.Fields()
if string(in) == "null" && md.FullName() != "google.protobuf.Value" {
return nil
}
if jsu, ok := proto.MessageV1(m.Interface()).(JSONPBUnmarshaler); ok {
return jsu.UnmarshalJSONPB(u, in)
}
switch wellKnownType(md.FullName()) {
case "Any":
var jsonObject map[string]json.RawMessage
if err := json.Unmarshal(in, &jsonObject); err != nil {
return err
}
rawTypeURL, ok := jsonObject["@type"]
if !ok {
return errors.New("Any JSON doesn't have '@type'")
}
typeURL, err := unquoteString(string(rawTypeURL))
if err != nil {
return fmt.Errorf("can't unmarshal Any's '@type': %q", rawTypeURL)
}
m.Set(fds.ByNumber(1), protoreflect.ValueOfString(typeURL))
var m2 protoreflect.Message
if u.AnyResolver != nil {
mi, err := u.AnyResolver.Resolve(typeURL)
if err != nil {
return err
}
m2 = proto.MessageReflect(mi)
} else {
mt, err := protoregistry.GlobalTypes.FindMessageByURL(typeURL)
if err != nil {
if err == protoregistry.NotFound {
return fmt.Errorf("could not resolve Any message type: %v", typeURL)
}
return err
}
m2 = mt.New()
}
if wellKnownType(m2.Descriptor().FullName()) != "" {
rawValue, ok := jsonObject["value"]
if !ok {
return errors.New("Any JSON doesn't have 'value'")
}
if err := u.unmarshalMessage(m2, rawValue); err != nil {
return fmt.Errorf("can't unmarshal Any nested proto %v: %v", typeURL, err)
}
} else {
delete(jsonObject, "@type")
rawJSON, err := json.Marshal(jsonObject)
if err != nil {
return fmt.Errorf("can't generate JSON for Any's nested proto to be unmarshaled: %v", err)
}
if err = u.unmarshalMessage(m2, rawJSON); err != nil {
return fmt.Errorf("can't unmarshal Any nested proto %v: %v", typeURL, err)
}
}
rawWire, err := protoV2.Marshal(m2.Interface())
if err != nil {
return fmt.Errorf("can't marshal proto %v into Any.Value: %v", typeURL, err)
}
m.Set(fds.ByNumber(2), protoreflect.ValueOfBytes(rawWire))
return nil
case "BoolValue", "BytesValue", "StringValue",
"Int32Value", "UInt32Value", "FloatValue",
"Int64Value", "UInt64Value", "DoubleValue":
fd := fds.ByNumber(1)
v, err := u.unmarshalValue(m.NewField(fd), in, fd)
if err != nil {
return err
}
m.Set(fd, v)
return nil
case "Duration":
v, err := unquoteString(string(in))
if err != nil {
return err
}
d, err := time.ParseDuration(v)
if err != nil {
return fmt.Errorf("bad Duration: %v", err)
}
sec := d.Nanoseconds() / 1e9
nsec := d.Nanoseconds() % 1e9
m.Set(fds.ByNumber(1), protoreflect.ValueOfInt64(int64(sec)))
m.Set(fds.ByNumber(2), protoreflect.ValueOfInt32(int32(nsec)))
return nil
case "Timestamp":
v, err := unquoteString(string(in))
if err != nil {
return err
}
t, err := time.Parse(time.RFC3339Nano, v)
if err != nil {
return fmt.Errorf("bad Timestamp: %v", err)
}
sec := t.Unix()
nsec := t.Nanosecond()
m.Set(fds.ByNumber(1), protoreflect.ValueOfInt64(int64(sec)))
m.Set(fds.ByNumber(2), protoreflect.ValueOfInt32(int32(nsec)))
return nil
case "Value":
switch {
case string(in) == "null":
m.Set(fds.ByNumber(1), protoreflect.ValueOfEnum(0))
case string(in) == "true":
m.Set(fds.ByNumber(4), protoreflect.ValueOfBool(true))
case string(in) == "false":
m.Set(fds.ByNumber(4), protoreflect.ValueOfBool(false))
case hasPrefixAndSuffix('"', in, '"'):
s, err := unquoteString(string(in))
if err != nil {
return fmt.Errorf("unrecognized type for Value %q", in)
}
m.Set(fds.ByNumber(3), protoreflect.ValueOfString(s))
case hasPrefixAndSuffix('[', in, ']'):
v := m.Mutable(fds.ByNumber(6))
return u.unmarshalMessage(v.Message(), in)
case hasPrefixAndSuffix('{', in, '}'):
v := m.Mutable(fds.ByNumber(5))
return u.unmarshalMessage(v.Message(), in)
default:
f, err := strconv.ParseFloat(string(in), 0)
if err != nil {
return fmt.Errorf("unrecognized type for Value %q", in)
}
m.Set(fds.ByNumber(2), protoreflect.ValueOfFloat64(f))
}
return nil
case "ListValue":
var jsonArray []json.RawMessage
if err := json.Unmarshal(in, &jsonArray); err != nil {
return fmt.Errorf("bad ListValue: %v", err)
}
lv := m.Mutable(fds.ByNumber(1)).List()
for _, raw := range jsonArray {
ve := lv.NewElement()
if err := u.unmarshalMessage(ve.Message(), raw); err != nil {
return err
}
lv.Append(ve)
}
return nil
case "Struct":
var jsonObject map[string]json.RawMessage
if err := json.Unmarshal(in, &jsonObject); err != nil {
return fmt.Errorf("bad StructValue: %v", err)
}
mv := m.Mutable(fds.ByNumber(1)).Map()
for key, raw := range jsonObject {
kv := protoreflect.ValueOf(key).MapKey()
vv := mv.NewValue()
if err := u.unmarshalMessage(vv.Message(), raw); err != nil {
return fmt.Errorf("bad value in StructValue for key %q: %v", key, err)
}
mv.Set(kv, vv)
}
return nil
}
var jsonObject map[string]json.RawMessage
if err := json.Unmarshal(in, &jsonObject); err != nil {
return err
}
// Handle known fields.
for i := 0; i < fds.Len(); i++ {
fd := fds.Get(i)
if fd.IsWeak() && fd.Message().IsPlaceholder() {
continue // weak reference is not linked in
}
// Search for any raw JSON value associated with this field.
var raw json.RawMessage
name := string(fd.Name())
if fd.Kind() == protoreflect.GroupKind {
name = string(fd.Message().Name())
}
if v, ok := jsonObject[name]; ok {
delete(jsonObject, name)
raw = v
}
name = string(fd.JSONName())
if v, ok := jsonObject[name]; ok {
delete(jsonObject, name)
raw = v
}
// Unmarshal the field value.
if raw == nil || (string(raw) == "null" && !isSingularWellKnownValue(fd)) {
continue
}
v, err := u.unmarshalValue(m.NewField(fd), raw, fd)
if err != nil {
return err
}
m.Set(fd, v)
}
// Handle extension fields.
for name, raw := range jsonObject {
if !strings.HasPrefix(name, "[") || !strings.HasSuffix(name, "]") {
continue
}
// Resolve the extension field by name.
xname := protoreflect.FullName(name[len("[") : len(name)-len("]")])
xt, _ := protoregistry.GlobalTypes.FindExtensionByName(xname)
if xt == nil && isMessageSet(md) {
xt, _ = protoregistry.GlobalTypes.FindExtensionByName(xname.Append("message_set_extension"))
}
if xt == nil {
continue
}
delete(jsonObject, name)
fd := xt.TypeDescriptor()
if fd.ContainingMessage().FullName() != m.Descriptor().FullName() {
return fmt.Errorf("extension field %q does not extend message %q", xname, m.Descriptor().FullName())
}
// Unmarshal the field value.
if raw == nil || (string(raw) == "null" && !isSingularWellKnownValue(fd)) {
continue
}
v, err := u.unmarshalValue(m.NewField(fd), raw, fd)
if err != nil {
return err
}
m.Set(fd, v)
}
if !u.AllowUnknownFields && len(jsonObject) > 0 {
for name := range jsonObject {
return fmt.Errorf("unknown field %q in %v", name, md.FullName())
}
}
return nil
}
func isSingularWellKnownValue(fd protoreflect.FieldDescriptor) bool {
if md := fd.Message(); md != nil {
return md.FullName() == "google.protobuf.Value" && fd.Cardinality() != protoreflect.Repeated
}
return false
}
func (u *Unmarshaler) unmarshalValue(v protoreflect.Value, in []byte, fd protoreflect.FieldDescriptor) (protoreflect.Value, error) {
switch {
case fd.IsList():
var jsonArray []json.RawMessage
if err := json.Unmarshal(in, &jsonArray); err != nil {
return v, err
}
lv := v.List()
for _, raw := range jsonArray {
ve, err := u.unmarshalSingularValue(lv.NewElement(), raw, fd)
if err != nil {
return v, err
}
lv.Append(ve)
}
return v, nil
case fd.IsMap():
var jsonObject map[string]json.RawMessage
if err := json.Unmarshal(in, &jsonObject); err != nil {
return v, err
}
kfd := fd.MapKey()
vfd := fd.MapValue()
mv := v.Map()
for key, raw := range jsonObject {
var kv protoreflect.MapKey
if kfd.Kind() == protoreflect.StringKind {
kv = protoreflect.ValueOf(key).MapKey()
} else {
v, err := u.unmarshalSingularValue(kfd.Default(), []byte(key), kfd)
if err != nil {
return v, err
}
kv = v.MapKey()
}
vv, err := u.unmarshalSingularValue(mv.NewValue(), raw, vfd)
if err != nil {
return v, err
}
mv.Set(kv, vv)
}
return v, nil
default:
return u.unmarshalSingularValue(v, in, fd)
}
}
var nonFinite = map[string]float64{
`"NaN"`: math.NaN(),
`"Infinity"`: math.Inf(+1),
`"-Infinity"`: math.Inf(-1),
}
func (u *Unmarshaler) unmarshalSingularValue(v protoreflect.Value, in []byte, fd protoreflect.FieldDescriptor) (protoreflect.Value, error) {
switch fd.Kind() {
case protoreflect.BoolKind:
return unmarshalValue(in, new(bool))
case protoreflect.Int32Kind, protoreflect.Sint32Kind, protoreflect.Sfixed32Kind:
return unmarshalValue(trimQuote(in), new(int32))
case protoreflect.Int64Kind, protoreflect.Sint64Kind, protoreflect.Sfixed64Kind:
return unmarshalValue(trimQuote(in), new(int64))
case protoreflect.Uint32Kind, protoreflect.Fixed32Kind:
return unmarshalValue(trimQuote(in), new(uint32))
case protoreflect.Uint64Kind, protoreflect.Fixed64Kind:
return unmarshalValue(trimQuote(in), new(uint64))
case protoreflect.FloatKind:
if f, ok := nonFinite[string(in)]; ok {
return protoreflect.ValueOfFloat32(float32(f)), nil
}
return unmarshalValue(trimQuote(in), new(float32))
case protoreflect.DoubleKind:
if f, ok := nonFinite[string(in)]; ok {
return protoreflect.ValueOfFloat64(float64(f)), nil
}
return unmarshalValue(trimQuote(in), new(float64))
case protoreflect.StringKind:
return unmarshalValue(in, new(string))
case protoreflect.BytesKind:
return unmarshalValue(in, new([]byte))
case protoreflect.EnumKind:
if hasPrefixAndSuffix('"', in, '"') {
vd := fd.Enum().Values().ByName(protoreflect.Name(trimQuote(in)))
if vd == nil {
return v, fmt.Errorf("unknown value %q for enum %s", in, fd.Enum().FullName())
}
return protoreflect.ValueOfEnum(vd.Number()), nil
}
return unmarshalValue(in, new(protoreflect.EnumNumber))
case protoreflect.MessageKind, protoreflect.GroupKind:
err := u.unmarshalMessage(v.Message(), in)
return v, err
default:
panic(fmt.Sprintf("invalid kind %v", fd.Kind()))
}
}
func unmarshalValue(in []byte, v interface{}) (protoreflect.Value, error) {
err := json.Unmarshal(in, v)
return protoreflect.ValueOf(reflect.ValueOf(v).Elem().Interface()), err
}
func unquoteString(in string) (out string, err error) {
err = json.Unmarshal([]byte(in), &out)
return out, err
}
func hasPrefixAndSuffix(prefix byte, in []byte, suffix byte) bool {
if len(in) >= 2 && in[0] == prefix && in[len(in)-1] == suffix {
return true
}
return false
}
// trimQuote is like unquoteString but simply strips surrounding quotes.
// This is incorrect, but is behavior done by the legacy implementation.
func trimQuote(in []byte) []byte {
if len(in) >= 2 && in[0] == '"' && in[len(in)-1] == '"' {
in = in[1 : len(in)-1]
}
return in
}

554
vendor/github.com/golang/protobuf/jsonpb/encode.go generated vendored Normal file
View file

@ -0,0 +1,554 @@
// Copyright 2015 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
package jsonpb
import (
"encoding/json"
"errors"
"fmt"
"io"
"math"
"reflect"
"sort"
"strconv"
"strings"
"time"
"github.com/golang/protobuf/proto"
"google.golang.org/protobuf/encoding/protojson"
protoV2 "google.golang.org/protobuf/proto"
"google.golang.org/protobuf/reflect/protoreflect"
"google.golang.org/protobuf/reflect/protoregistry"
)
const wrapJSONMarshalV2 = false
// Marshaler is a configurable object for marshaling protocol buffer messages
// to the specified JSON representation.
type Marshaler struct {
// OrigName specifies whether to use the original protobuf name for fields.
OrigName bool
// EnumsAsInts specifies whether to render enum values as integers,
// as opposed to string values.
EnumsAsInts bool
// EmitDefaults specifies whether to render fields with zero values.
EmitDefaults bool
// Indent controls whether the output is compact or not.
// If empty, the output is compact JSON. Otherwise, every JSON object
// entry and JSON array value will be on its own line.
// Each line will be preceded by repeated copies of Indent, where the
// number of copies is the current indentation depth.
Indent string
// AnyResolver is used to resolve the google.protobuf.Any well-known type.
// If unset, the global registry is used by default.
AnyResolver AnyResolver
}
// JSONPBMarshaler is implemented by protobuf messages that customize the
// way they are marshaled to JSON. Messages that implement this should also
// implement JSONPBUnmarshaler so that the custom format can be parsed.
//
// The JSON marshaling must follow the proto to JSON specification:
// https://developers.google.com/protocol-buffers/docs/proto3#json
//
// Deprecated: Custom types should implement protobuf reflection instead.
type JSONPBMarshaler interface {
MarshalJSONPB(*Marshaler) ([]byte, error)
}
// Marshal serializes a protobuf message as JSON into w.
func (jm *Marshaler) Marshal(w io.Writer, m proto.Message) error {
b, err := jm.marshal(m)
if len(b) > 0 {
if _, err := w.Write(b); err != nil {
return err
}
}
return err
}
// MarshalToString serializes a protobuf message as JSON in string form.
func (jm *Marshaler) MarshalToString(m proto.Message) (string, error) {
b, err := jm.marshal(m)
if err != nil {
return "", err
}
return string(b), nil
}
func (jm *Marshaler) marshal(m proto.Message) ([]byte, error) {
v := reflect.ValueOf(m)
if m == nil || (v.Kind() == reflect.Ptr && v.IsNil()) {
return nil, errors.New("Marshal called with nil")
}
// Check for custom marshalers first since they may not properly
// implement protobuf reflection that the logic below relies on.
if jsm, ok := m.(JSONPBMarshaler); ok {
return jsm.MarshalJSONPB(jm)
}
if wrapJSONMarshalV2 {
opts := protojson.MarshalOptions{
UseProtoNames: jm.OrigName,
UseEnumNumbers: jm.EnumsAsInts,
EmitUnpopulated: jm.EmitDefaults,
Indent: jm.Indent,
}
if jm.AnyResolver != nil {
opts.Resolver = anyResolver{jm.AnyResolver}
}
return opts.Marshal(proto.MessageReflect(m).Interface())
} else {
// Check for unpopulated required fields first.
m2 := proto.MessageReflect(m)
if err := protoV2.CheckInitialized(m2.Interface()); err != nil {
return nil, err
}
w := jsonWriter{Marshaler: jm}
err := w.marshalMessage(m2, "", "")
return w.buf, err
}
}
type jsonWriter struct {
*Marshaler
buf []byte
}
func (w *jsonWriter) write(s string) {
w.buf = append(w.buf, s...)
}
func (w *jsonWriter) marshalMessage(m protoreflect.Message, indent, typeURL string) error {
if jsm, ok := proto.MessageV1(m.Interface()).(JSONPBMarshaler); ok {
b, err := jsm.MarshalJSONPB(w.Marshaler)
if err != nil {
return err
}
if typeURL != "" {
// we are marshaling this object to an Any type
var js map[string]*json.RawMessage
if err = json.Unmarshal(b, &js); err != nil {
return fmt.Errorf("type %T produced invalid JSON: %v", m.Interface(), err)
}
turl, err := json.Marshal(typeURL)
if err != nil {
return fmt.Errorf("failed to marshal type URL %q to JSON: %v", typeURL, err)
}
js["@type"] = (*json.RawMessage)(&turl)
if b, err = json.Marshal(js); err != nil {
return err
}
}
w.write(string(b))
return nil
}
md := m.Descriptor()
fds := md.Fields()
// Handle well-known types.
const secondInNanos = int64(time.Second / time.Nanosecond)
switch wellKnownType(md.FullName()) {
case "Any":
return w.marshalAny(m, indent)
case "BoolValue", "BytesValue", "StringValue",
"Int32Value", "UInt32Value", "FloatValue",
"Int64Value", "UInt64Value", "DoubleValue":
fd := fds.ByNumber(1)
return w.marshalValue(fd, m.Get(fd), indent)
case "Duration":
// "Generated output always contains 0, 3, 6, or 9 fractional digits,
// depending on required precision."
s := m.Get(fds.ByNumber(1)).Int()
ns := m.Get(fds.ByNumber(2)).Int()
if ns <= -secondInNanos || ns >= secondInNanos {
return fmt.Errorf("ns out of range (%v, %v)", -secondInNanos, secondInNanos)
}
if (s > 0 && ns < 0) || (s < 0 && ns > 0) {
return errors.New("signs of seconds and nanos do not match")
}
if s < 0 {
ns = -ns
}
x := fmt.Sprintf("%d.%09d", s, ns)
x = strings.TrimSuffix(x, "000")
x = strings.TrimSuffix(x, "000")
x = strings.TrimSuffix(x, ".000")
w.write(fmt.Sprintf(`"%vs"`, x))
return nil
case "Timestamp":
// "RFC 3339, where generated output will always be Z-normalized
// and uses 0, 3, 6 or 9 fractional digits."
s := m.Get(fds.ByNumber(1)).Int()
ns := m.Get(fds.ByNumber(2)).Int()
if ns < 0 || ns >= secondInNanos {
return fmt.Errorf("ns out of range [0, %v)", secondInNanos)
}
t := time.Unix(s, ns).UTC()
// time.RFC3339Nano isn't exactly right (we need to get 3/6/9 fractional digits).
x := t.Format("2006-01-02T15:04:05.000000000")
x = strings.TrimSuffix(x, "000")
x = strings.TrimSuffix(x, "000")
x = strings.TrimSuffix(x, ".000")
w.write(fmt.Sprintf(`"%vZ"`, x))
return nil
case "Value":
// JSON value; which is a null, number, string, bool, object, or array.
od := md.Oneofs().Get(0)
fd := m.WhichOneof(od)
if fd == nil {
return errors.New("nil Value")
}
return w.marshalValue(fd, m.Get(fd), indent)
case "Struct", "ListValue":
// JSON object or array.
fd := fds.ByNumber(1)
return w.marshalValue(fd, m.Get(fd), indent)
}
w.write("{")
if w.Indent != "" {
w.write("\n")
}
firstField := true
if typeURL != "" {
if err := w.marshalTypeURL(indent, typeURL); err != nil {
return err
}
firstField = false
}
for i := 0; i < fds.Len(); {
fd := fds.Get(i)
if od := fd.ContainingOneof(); od != nil {
fd = m.WhichOneof(od)
i += od.Fields().Len()
if fd == nil {
continue
}
} else {
i++
}
v := m.Get(fd)
if !m.Has(fd) {
if !w.EmitDefaults || fd.ContainingOneof() != nil {
continue
}
if fd.Cardinality() != protoreflect.Repeated && (fd.Message() != nil || fd.Syntax() == protoreflect.Proto2) {
v = protoreflect.Value{} // use "null" for singular messages or proto2 scalars
}
}
if !firstField {
w.writeComma()
}
if err := w.marshalField(fd, v, indent); err != nil {
return err
}
firstField = false
}
// Handle proto2 extensions.
if md.ExtensionRanges().Len() > 0 {
// Collect a sorted list of all extension descriptor and values.
type ext struct {
desc protoreflect.FieldDescriptor
val protoreflect.Value
}
var exts []ext
m.Range(func(fd protoreflect.FieldDescriptor, v protoreflect.Value) bool {
if fd.IsExtension() {
exts = append(exts, ext{fd, v})
}
return true
})
sort.Slice(exts, func(i, j int) bool {
return exts[i].desc.Number() < exts[j].desc.Number()
})
for _, ext := range exts {
if !firstField {
w.writeComma()
}
if err := w.marshalField(ext.desc, ext.val, indent); err != nil {
return err
}
firstField = false
}
}
if w.Indent != "" {
w.write("\n")
w.write(indent)
}
w.write("}")
return nil
}
func (w *jsonWriter) writeComma() {
if w.Indent != "" {
w.write(",\n")
} else {
w.write(",")
}
}
func (w *jsonWriter) marshalAny(m protoreflect.Message, indent string) error {
// "If the Any contains a value that has a special JSON mapping,
// it will be converted as follows: {"@type": xxx, "value": yyy}.
// Otherwise, the value will be converted into a JSON object,
// and the "@type" field will be inserted to indicate the actual data type."
md := m.Descriptor()
typeURL := m.Get(md.Fields().ByNumber(1)).String()
rawVal := m.Get(md.Fields().ByNumber(2)).Bytes()
var m2 protoreflect.Message
if w.AnyResolver != nil {
mi, err := w.AnyResolver.Resolve(typeURL)
if err != nil {
return err
}
m2 = proto.MessageReflect(mi)
} else {
mt, err := protoregistry.GlobalTypes.FindMessageByURL(typeURL)
if err != nil {
return err
}
m2 = mt.New()
}
if err := protoV2.Unmarshal(rawVal, m2.Interface()); err != nil {
return err
}
if wellKnownType(m2.Descriptor().FullName()) == "" {
return w.marshalMessage(m2, indent, typeURL)
}
w.write("{")
if w.Indent != "" {
w.write("\n")
}
if err := w.marshalTypeURL(indent, typeURL); err != nil {
return err
}
w.writeComma()
if w.Indent != "" {
w.write(indent)
w.write(w.Indent)
w.write(`"value": `)
} else {
w.write(`"value":`)
}
if err := w.marshalMessage(m2, indent+w.Indent, ""); err != nil {
return err
}
if w.Indent != "" {
w.write("\n")
w.write(indent)
}
w.write("}")
return nil
}
func (w *jsonWriter) marshalTypeURL(indent, typeURL string) error {
if w.Indent != "" {
w.write(indent)
w.write(w.Indent)
}
w.write(`"@type":`)
if w.Indent != "" {
w.write(" ")
}
b, err := json.Marshal(typeURL)
if err != nil {
return err
}
w.write(string(b))
return nil
}
// marshalField writes field description and value to the Writer.
func (w *jsonWriter) marshalField(fd protoreflect.FieldDescriptor, v protoreflect.Value, indent string) error {
if w.Indent != "" {
w.write(indent)
w.write(w.Indent)
}
w.write(`"`)
switch {
case fd.IsExtension():
// For message set, use the fname of the message as the extension name.
name := string(fd.FullName())
if isMessageSet(fd.ContainingMessage()) {
name = strings.TrimSuffix(name, ".message_set_extension")
}
w.write("[" + name + "]")
case w.OrigName:
name := string(fd.Name())
if fd.Kind() == protoreflect.GroupKind {
name = string(fd.Message().Name())
}
w.write(name)
default:
w.write(string(fd.JSONName()))
}
w.write(`":`)
if w.Indent != "" {
w.write(" ")
}
return w.marshalValue(fd, v, indent)
}
func (w *jsonWriter) marshalValue(fd protoreflect.FieldDescriptor, v protoreflect.Value, indent string) error {
switch {
case fd.IsList():
w.write("[")
comma := ""
lv := v.List()
for i := 0; i < lv.Len(); i++ {
w.write(comma)
if w.Indent != "" {
w.write("\n")
w.write(indent)
w.write(w.Indent)
w.write(w.Indent)
}
if err := w.marshalSingularValue(fd, lv.Get(i), indent+w.Indent); err != nil {
return err
}
comma = ","
}
if w.Indent != "" {
w.write("\n")
w.write(indent)
w.write(w.Indent)
}
w.write("]")
return nil
case fd.IsMap():
kfd := fd.MapKey()
vfd := fd.MapValue()
mv := v.Map()
// Collect a sorted list of all map keys and values.
type entry struct{ key, val protoreflect.Value }
var entries []entry
mv.Range(func(k protoreflect.MapKey, v protoreflect.Value) bool {
entries = append(entries, entry{k.Value(), v})
return true
})
sort.Slice(entries, func(i, j int) bool {
switch kfd.Kind() {
case protoreflect.BoolKind:
return !entries[i].key.Bool() && entries[j].key.Bool()
case protoreflect.Int32Kind, protoreflect.Sint32Kind, protoreflect.Sfixed32Kind, protoreflect.Int64Kind, protoreflect.Sint64Kind, protoreflect.Sfixed64Kind:
return entries[i].key.Int() < entries[j].key.Int()
case protoreflect.Uint32Kind, protoreflect.Fixed32Kind, protoreflect.Uint64Kind, protoreflect.Fixed64Kind:
return entries[i].key.Uint() < entries[j].key.Uint()
case protoreflect.StringKind:
return entries[i].key.String() < entries[j].key.String()
default:
panic("invalid kind")
}
})
w.write(`{`)
comma := ""
for _, entry := range entries {
w.write(comma)
if w.Indent != "" {
w.write("\n")
w.write(indent)
w.write(w.Indent)
w.write(w.Indent)
}
s := fmt.Sprint(entry.key.Interface())
b, err := json.Marshal(s)
if err != nil {
return err
}
w.write(string(b))
w.write(`:`)
if w.Indent != "" {
w.write(` `)
}
if err := w.marshalSingularValue(vfd, entry.val, indent+w.Indent); err != nil {
return err
}
comma = ","
}
if w.Indent != "" {
w.write("\n")
w.write(indent)
w.write(w.Indent)
}
w.write(`}`)
return nil
default:
return w.marshalSingularValue(fd, v, indent)
}
}
func (w *jsonWriter) marshalSingularValue(fd protoreflect.FieldDescriptor, v protoreflect.Value, indent string) error {
switch {
case !v.IsValid():
w.write("null")
return nil
case fd.Message() != nil:
return w.marshalMessage(v.Message(), indent+w.Indent, "")
case fd.Enum() != nil:
if fd.Enum().FullName() == "google.protobuf.NullValue" {
w.write("null")
return nil
}
vd := fd.Enum().Values().ByNumber(v.Enum())
if vd == nil || w.EnumsAsInts {
w.write(strconv.Itoa(int(v.Enum())))
} else {
w.write(`"` + string(vd.Name()) + `"`)
}
return nil
default:
switch v.Interface().(type) {
case float32, float64:
switch {
case math.IsInf(v.Float(), +1):
w.write(`"Infinity"`)
return nil
case math.IsInf(v.Float(), -1):
w.write(`"-Infinity"`)
return nil
case math.IsNaN(v.Float()):
w.write(`"NaN"`)
return nil
}
case int64, uint64:
w.write(fmt.Sprintf(`"%d"`, v.Interface()))
return nil
}
b, err := json.Marshal(v.Interface())
if err != nil {
return err
}
w.write(string(b))
return nil
}
}

69
vendor/github.com/golang/protobuf/jsonpb/json.go generated vendored Normal file
View file

@ -0,0 +1,69 @@
// Copyright 2015 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
// Package jsonpb provides functionality to marshal and unmarshal between a
// protocol buffer message and JSON. It follows the specification at
// https://developers.google.com/protocol-buffers/docs/proto3#json.
//
// Do not rely on the default behavior of the standard encoding/json package
// when called on generated message types as it does not operate correctly.
//
// Deprecated: Use the "google.golang.org/protobuf/encoding/protojson"
// package instead.
package jsonpb
import (
"github.com/golang/protobuf/proto"
"google.golang.org/protobuf/reflect/protoreflect"
"google.golang.org/protobuf/reflect/protoregistry"
"google.golang.org/protobuf/runtime/protoimpl"
)
// AnyResolver takes a type URL, present in an Any message,
// and resolves it into an instance of the associated message.
type AnyResolver interface {
Resolve(typeURL string) (proto.Message, error)
}
type anyResolver struct{ AnyResolver }
func (r anyResolver) FindMessageByName(message protoreflect.FullName) (protoreflect.MessageType, error) {
return r.FindMessageByURL(string(message))
}
func (r anyResolver) FindMessageByURL(url string) (protoreflect.MessageType, error) {
m, err := r.Resolve(url)
if err != nil {
return nil, err
}
return protoimpl.X.MessageTypeOf(m), nil
}
func (r anyResolver) FindExtensionByName(field protoreflect.FullName) (protoreflect.ExtensionType, error) {
return protoregistry.GlobalTypes.FindExtensionByName(field)
}
func (r anyResolver) FindExtensionByNumber(message protoreflect.FullName, field protoreflect.FieldNumber) (protoreflect.ExtensionType, error) {
return protoregistry.GlobalTypes.FindExtensionByNumber(message, field)
}
func wellKnownType(s protoreflect.FullName) string {
if s.Parent() == "google.protobuf" {
switch s.Name() {
case "Empty", "Any",
"BoolValue", "BytesValue", "StringValue",
"Int32Value", "UInt32Value", "FloatValue",
"Int64Value", "UInt64Value", "DoubleValue",
"Duration", "Timestamp",
"NullValue", "Struct", "Value", "ListValue":
return string(s.Name())
}
}
return ""
}
func isMessageSet(md protoreflect.MessageDescriptor) bool {
ms, ok := md.(interface{ IsMessageSet() bool })
return ok && ms.IsMessageSet()
}

1290
vendor/github.com/golang/protobuf/jsonpb/jsonpb.go generated vendored
View file

File diff suppressed because it is too large Load diff

324
vendor/github.com/golang/protobuf/proto/buffer.go generated vendored Normal file
View file

@ -0,0 +1,324 @@
// Copyright 2019 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
package proto
import (
"errors"
"fmt"
"google.golang.org/protobuf/encoding/prototext"
"google.golang.org/protobuf/encoding/protowire"
"google.golang.org/protobuf/runtime/protoimpl"
)
const (
WireVarint = 0
WireFixed32 = 5
WireFixed64 = 1
WireBytes = 2
WireStartGroup = 3
WireEndGroup = 4
)
// EncodeVarint returns the varint encoded bytes of v.
func EncodeVarint(v uint64) []byte {
return protowire.AppendVarint(nil, v)
}
// SizeVarint returns the length of the varint encoded bytes of v.
// This is equal to len(EncodeVarint(v)).
func SizeVarint(v uint64) int {
return protowire.SizeVarint(v)
}
// DecodeVarint parses a varint encoded integer from b,
// returning the integer value and the length of the varint.
// It returns (0, 0) if there is a parse error.
func DecodeVarint(b []byte) (uint64, int) {
v, n := protowire.ConsumeVarint(b)
if n < 0 {
return 0, 0
}
return v, n
}
// Buffer is a buffer for encoding and decoding the protobuf wire format.
// It may be reused between invocations to reduce memory usage.
type Buffer struct {
buf []byte
idx int
deterministic bool
}
// NewBuffer allocates a new Buffer initialized with buf,
// where the contents of buf are considered the unread portion of the buffer.
func NewBuffer(buf []byte) *Buffer {
return &Buffer{buf: buf}
}
// SetDeterministic specifies whether to use deterministic serialization.
//
// Deterministic serialization guarantees that for a given binary, equal
// messages will always be serialized to the same bytes. This implies:
//
// - Repeated serialization of a message will return the same bytes.
// - Different processes of the same binary (which may be executing on
// different machines) will serialize equal messages to the same bytes.
//
// Note that the deterministic serialization is NOT canonical across
// languages. It is not guaranteed to remain stable over time. It is unstable
// across different builds with schema changes due to unknown fields.
// Users who need canonical serialization (e.g., persistent storage in a
// canonical form, fingerprinting, etc.) should define their own
// canonicalization specification and implement their own serializer rather
// than relying on this API.
//
// If deterministic serialization is requested, map entries will be sorted
// by keys in lexographical order. This is an implementation detail and
// subject to change.
func (b *Buffer) SetDeterministic(deterministic bool) {
b.deterministic = deterministic
}
// SetBuf sets buf as the internal buffer,
// where the contents of buf are considered the unread portion of the buffer.
func (b *Buffer) SetBuf(buf []byte) {
b.buf = buf
b.idx = 0
}
// Reset clears the internal buffer of all written and unread data.
func (b *Buffer) Reset() {
b.buf = b.buf[:0]
b.idx = 0
}
// Bytes returns the internal buffer.
func (b *Buffer) Bytes() []byte {
return b.buf
}
// Unread returns the unread portion of the buffer.
func (b *Buffer) Unread() []byte {
return b.buf[b.idx:]
}
// Marshal appends the wire-format encoding of m to the buffer.
func (b *Buffer) Marshal(m Message) error {
var err error
b.buf, err = marshalAppend(b.buf, m, b.deterministic)
return err
}
// Unmarshal parses the wire-format message in the buffer and
// places the decoded results in m.
// It does not reset m before unmarshaling.
func (b *Buffer) Unmarshal(m Message) error {
err := UnmarshalMerge(b.Unread(), m)
b.idx = len(b.buf)
return err
}
type unknownFields struct{ XXX_unrecognized protoimpl.UnknownFields }
func (m *unknownFields) String() string { panic("not implemented") }
func (m *unknownFields) Reset() { panic("not implemented") }
func (m *unknownFields) ProtoMessage() { panic("not implemented") }
// DebugPrint dumps the encoded bytes of b with a header and footer including s
// to stdout. This is only intended for debugging.
func (*Buffer) DebugPrint(s string, b []byte) {
m := MessageReflect(new(unknownFields))
m.SetUnknown(b)
b, _ = prototext.MarshalOptions{AllowPartial: true, Indent: "\t"}.Marshal(m.Interface())
fmt.Printf("==== %s ====\n%s==== %s ====\n", s, b, s)
}
// EncodeVarint appends an unsigned varint encoding to the buffer.
func (b *Buffer) EncodeVarint(v uint64) error {
b.buf = protowire.AppendVarint(b.buf, v)
return nil
}
// EncodeZigzag32 appends a 32-bit zig-zag varint encoding to the buffer.
func (b *Buffer) EncodeZigzag32(v uint64) error {
return b.EncodeVarint(uint64((uint32(v) << 1) ^ uint32((int32(v) >> 31))))
}
// EncodeZigzag64 appends a 64-bit zig-zag varint encoding to the buffer.
func (b *Buffer) EncodeZigzag64(v uint64) error {
return b.EncodeVarint(uint64((uint64(v) << 1) ^ uint64((int64(v) >> 63))))
}
// EncodeFixed32 appends a 32-bit little-endian integer to the buffer.
func (b *Buffer) EncodeFixed32(v uint64) error {
b.buf = protowire.AppendFixed32(b.buf, uint32(v))
return nil
}
// EncodeFixed64 appends a 64-bit little-endian integer to the buffer.
func (b *Buffer) EncodeFixed64(v uint64) error {
b.buf = protowire.AppendFixed64(b.buf, uint64(v))
return nil
}
// EncodeRawBytes appends a length-prefixed raw bytes to the buffer.
func (b *Buffer) EncodeRawBytes(v []byte) error {
b.buf = protowire.AppendBytes(b.buf, v)
return nil
}
// EncodeStringBytes appends a length-prefixed raw bytes to the buffer.
// It does not validate whether v contains valid UTF-8.
func (b *Buffer) EncodeStringBytes(v string) error {
b.buf = protowire.AppendString(b.buf, v)
return nil
}
// EncodeMessage appends a length-prefixed encoded message to the buffer.
func (b *Buffer) EncodeMessage(m Message) error {
var err error
b.buf = protowire.AppendVarint(b.buf, uint64(Size(m)))
b.buf, err = marshalAppend(b.buf, m, b.deterministic)
return err
}
// DecodeVarint consumes an encoded unsigned varint from the buffer.
func (b *Buffer) DecodeVarint() (uint64, error) {
v, n := protowire.ConsumeVarint(b.buf[b.idx:])
if n < 0 {
return 0, protowire.ParseError(n)
}
b.idx += n
return uint64(v), nil
}
// DecodeZigzag32 consumes an encoded 32-bit zig-zag varint from the buffer.
func (b *Buffer) DecodeZigzag32() (uint64, error) {
v, err := b.DecodeVarint()
if err != nil {
return 0, err
}
return uint64((uint32(v) >> 1) ^ uint32((int32(v&1)<<31)>>31)), nil
}
// DecodeZigzag64 consumes an encoded 64-bit zig-zag varint from the buffer.
func (b *Buffer) DecodeZigzag64() (uint64, error) {
v, err := b.DecodeVarint()
if err != nil {
return 0, err
}
return uint64((uint64(v) >> 1) ^ uint64((int64(v&1)<<63)>>63)), nil
}
// DecodeFixed32 consumes a 32-bit little-endian integer from the buffer.
func (b *Buffer) DecodeFixed32() (uint64, error) {
v, n := protowire.ConsumeFixed32(b.buf[b.idx:])
if n < 0 {
return 0, protowire.ParseError(n)
}
b.idx += n
return uint64(v), nil
}
// DecodeFixed64 consumes a 64-bit little-endian integer from the buffer.
func (b *Buffer) DecodeFixed64() (uint64, error) {
v, n := protowire.ConsumeFixed64(b.buf[b.idx:])
if n < 0 {
return 0, protowire.ParseError(n)
}
b.idx += n
return uint64(v), nil
}
// DecodeRawBytes consumes a length-prefixed raw bytes from the buffer.
// If alloc is specified, it returns a copy the raw bytes
// rather than a sub-slice of the buffer.
func (b *Buffer) DecodeRawBytes(alloc bool) ([]byte, error) {
v, n := protowire.ConsumeBytes(b.buf[b.idx:])
if n < 0 {
return nil, protowire.ParseError(n)
}
b.idx += n
if alloc {
v = append([]byte(nil), v...)
}
return v, nil
}
// DecodeStringBytes consumes a length-prefixed raw bytes from the buffer.
// It does not validate whether the raw bytes contain valid UTF-8.
func (b *Buffer) DecodeStringBytes() (string, error) {
v, n := protowire.ConsumeString(b.buf[b.idx:])
if n < 0 {
return "", protowire.ParseError(n)
}
b.idx += n
return v, nil
}
// DecodeMessage consumes a length-prefixed message from the buffer.
// It does not reset m before unmarshaling.
func (b *Buffer) DecodeMessage(m Message) error {
v, err := b.DecodeRawBytes(false)
if err != nil {
return err
}
return UnmarshalMerge(v, m)
}
// DecodeGroup consumes a message group from the buffer.
// It assumes that the start group marker has already been consumed and
// consumes all bytes until (and including the end group marker).
// It does not reset m before unmarshaling.
func (b *Buffer) DecodeGroup(m Message) error {
v, n, err := consumeGroup(b.buf[b.idx:])
if err != nil {
return err
}
b.idx += n
return UnmarshalMerge(v, m)
}
// consumeGroup parses b until it finds an end group marker, returning
// the raw bytes of the message (excluding the end group marker) and the
// the total length of the message (including the end group marker).
func consumeGroup(b []byte) ([]byte, int, error) {
b0 := b
depth := 1 // assume this follows a start group marker
for {
_, wtyp, tagLen := protowire.ConsumeTag(b)
if tagLen < 0 {
return nil, 0, protowire.ParseError(tagLen)
}
b = b[tagLen:]
var valLen int
switch wtyp {
case protowire.VarintType:
_, valLen = protowire.ConsumeVarint(b)
case protowire.Fixed32Type:
_, valLen = protowire.ConsumeFixed32(b)
case protowire.Fixed64Type:
_, valLen = protowire.ConsumeFixed64(b)
case protowire.BytesType:
_, valLen = protowire.ConsumeBytes(b)
case protowire.StartGroupType:
depth++
case protowire.EndGroupType:
depth--
default:
return nil, 0, errors.New("proto: cannot parse reserved wire type")
}
if valLen < 0 {
return nil, 0, protowire.ParseError(valLen)
}
b = b[valLen:]
if depth == 0 {
return b0[:len(b0)-len(b)-tagLen], len(b0) - len(b), nil
}
}
}

253
vendor/github.com/golang/protobuf/proto/clone.go generated vendored
View file

@ -1,253 +0,0 @@
// Go support for Protocol Buffers - Google's data interchange format
//
// Copyright 2011 The Go Authors. All rights reserved.
// https://github.com/golang/protobuf
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
// * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
// * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following disclaimer
// in the documentation and/or other materials provided with the
// distribution.
// * Neither the name of Google Inc. nor the names of its
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
// Protocol buffer deep copy and merge.
// TODO: RawMessage.
package proto
import (
"fmt"
"log"
"reflect"
"strings"
)
// Clone returns a deep copy of a protocol buffer.
func Clone(src Message) Message {
in := reflect.ValueOf(src)
if in.IsNil() {
return src
}
out := reflect.New(in.Type().Elem())
dst := out.Interface().(Message)
Merge(dst, src)
return dst
}
// Merger is the interface representing objects that can merge messages of the same type.
type Merger interface {
// Merge merges src into this message.
// Required and optional fields that are set in src will be set to that value in dst.
// Elements of repeated fields will be appended.
//
// Merge may panic if called with a different argument type than the receiver.
Merge(src Message)
}
// generatedMerger is the custom merge method that generated protos will have.
// We must add this method since a generate Merge method will conflict with
// many existing protos that have a Merge data field already defined.
type generatedMerger interface {
XXX_Merge(src Message)
}
// Merge merges src into dst.
// Required and optional fields that are set in src will be set to that value in dst.
// Elements of repeated fields will be appended.
// Merge panics if src and dst are not the same type, or if dst is nil.
func Merge(dst, src Message) {
if m, ok := dst.(Merger); ok {
m.Merge(src)
return
}
in := reflect.ValueOf(src)
out := reflect.ValueOf(dst)
if out.IsNil() {
panic("proto: nil destination")
}
if in.Type() != out.Type() {
panic(fmt.Sprintf("proto.Merge(%T, %T) type mismatch", dst, src))
}
if in.IsNil() {
return // Merge from nil src is a noop
}
if m, ok := dst.(generatedMerger); ok {
m.XXX_Merge(src)
return
}
mergeStruct(out.Elem(), in.Elem())
}
func mergeStruct(out, in reflect.Value) {
sprop := GetProperties(in.Type())
for i := 0; i < in.NumField(); i++ {
f := in.Type().Field(i)
if strings.HasPrefix(f.Name, "XXX_") {
continue
}
mergeAny(out.Field(i), in.Field(i), false, sprop.Prop[i])
}
if emIn, err := extendable(in.Addr().Interface()); err == nil {
emOut, _ := extendable(out.Addr().Interface())
mIn, muIn := emIn.extensionsRead()
if mIn != nil {
mOut := emOut.extensionsWrite()
muIn.Lock()
mergeExtension(mOut, mIn)
muIn.Unlock()
}
}
uf := in.FieldByName("XXX_unrecognized")
if !uf.IsValid() {
return
}
uin := uf.Bytes()
if len(uin) > 0 {
out.FieldByName("XXX_unrecognized").SetBytes(append([]byte(nil), uin...))
}
}
// mergeAny performs a merge between two values of the same type.
// viaPtr indicates whether the values were indirected through a pointer (implying proto2).
// prop is set if this is a struct field (it may be nil).
func mergeAny(out, in reflect.Value, viaPtr bool, prop *Properties) {
if in.Type() == protoMessageType {
if !in.IsNil() {
if out.IsNil() {
out.Set(reflect.ValueOf(Clone(in.Interface().(Message))))
} else {
Merge(out.Interface().(Message), in.Interface().(Message))
}
}
return
}
switch in.Kind() {
case reflect.Bool, reflect.Float32, reflect.Float64, reflect.Int32, reflect.Int64,
reflect.String, reflect.Uint32, reflect.Uint64:
if !viaPtr && isProto3Zero(in) {
return
}
out.Set(in)
case reflect.Interface:
// Probably a oneof field; copy non-nil values.
if in.IsNil() {
return
}
// Allocate destination if it is not set, or set to a different type.
// Otherwise we will merge as normal.
if out.IsNil() || out.Elem().Type() != in.Elem().Type() {
out.Set(reflect.New(in.Elem().Elem().Type())) // interface -> *T -> T -> new(T)
}
mergeAny(out.Elem(), in.Elem(), false, nil)
case reflect.Map:
if in.Len() == 0 {
return
}
if out.IsNil() {
out.Set(reflect.MakeMap(in.Type()))
}
// For maps with value types of *T or []byte we need to deep copy each value.
elemKind := in.Type().Elem().Kind()
for _, key := range in.MapKeys() {
var val reflect.Value
switch elemKind {
case reflect.Ptr:
val = reflect.New(in.Type().Elem().Elem())
mergeAny(val, in.MapIndex(key), false, nil)
case reflect.Slice:
val = in.MapIndex(key)
val = reflect.ValueOf(append([]byte{}, val.Bytes()...))
default:
val = in.MapIndex(key)
}
out.SetMapIndex(key, val)
}
case reflect.Ptr:
if in.IsNil() {
return
}
if out.IsNil() {
out.Set(reflect.New(in.Elem().Type()))
}
mergeAny(out.Elem(), in.Elem(), true, nil)
case reflect.Slice:
if in.IsNil() {
return
}
if in.Type().Elem().Kind() == reflect.Uint8 {
// []byte is a scalar bytes field, not a repeated field.
// Edge case: if this is in a proto3 message, a zero length
// bytes field is considered the zero value, and should not
// be merged.
if prop != nil && prop.proto3 && in.Len() == 0 {
return
}
// Make a deep copy.
// Append to []byte{} instead of []byte(nil) so that we never end up
// with a nil result.
out.SetBytes(append([]byte{}, in.Bytes()...))
return
}
n := in.Len()
if out.IsNil() {
out.Set(reflect.MakeSlice(in.Type(), 0, n))
}
switch in.Type().Elem().Kind() {
case reflect.Bool, reflect.Float32, reflect.Float64, reflect.Int32, reflect.Int64,
reflect.String, reflect.Uint32, reflect.Uint64:
out.Set(reflect.AppendSlice(out, in))
default:
for i := 0; i < n; i++ {
x := reflect.Indirect(reflect.New(in.Type().Elem()))
mergeAny(x, in.Index(i), false, nil)
out.Set(reflect.Append(out, x))
}
}
case reflect.Struct:
mergeStruct(out, in)
default:
// unknown type, so not a protocol buffer
log.Printf("proto: don't know how to copy %v", in)
}
}
func mergeExtension(out, in map[int32]Extension) {
for extNum, eIn := range in {
eOut := Extension{desc: eIn.desc}
if eIn.value != nil {
v := reflect.New(reflect.TypeOf(eIn.value)).Elem()
mergeAny(v, reflect.ValueOf(eIn.value), false, nil)
eOut.value = v.Interface()
}
if eIn.enc != nil {
eOut.enc = make([]byte, len(eIn.enc))
copy(eOut.enc, eIn.enc)
}
out[extNum] = eOut
}
}

427
vendor/github.com/golang/protobuf/proto/decode.go generated vendored
View file

@ -1,427 +0,0 @@
// Go support for Protocol Buffers - Google's data interchange format
//
// Copyright 2010 The Go Authors. All rights reserved.
// https://github.com/golang/protobuf
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
// * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
// * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following disclaimer
// in the documentation and/or other materials provided with the
// distribution.
// * Neither the name of Google Inc. nor the names of its
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
package proto
/*
* Routines for decoding protocol buffer data to construct in-memory representations.
*/
import (
"errors"
"fmt"
"io"
)
// errOverflow is returned when an integer is too large to be represented.
var errOverflow = errors.New("proto: integer overflow")
// ErrInternalBadWireType is returned by generated code when an incorrect
// wire type is encountered. It does not get returned to user code.
var ErrInternalBadWireType = errors.New("proto: internal error: bad wiretype for oneof")
// DecodeVarint reads a varint-encoded integer from the slice.
// It returns the integer and the number of bytes consumed, or
// zero if there is not enough.
// This is the format for the
// int32, int64, uint32, uint64, bool, and enum
// protocol buffer types.
func DecodeVarint(buf []byte) (x uint64, n int) {
for shift := uint(0); shift < 64; shift += 7 {
if n >= len(buf) {
return 0, 0
}
b := uint64(buf[n])
n++
x |= (b & 0x7F) << shift
if (b & 0x80) == 0 {
return x, n
}
}
// The number is too large to represent in a 64-bit value.
return 0, 0
}
func (p *Buffer) decodeVarintSlow() (x uint64, err error) {
i := p.index
l := len(p.buf)
for shift := uint(0); shift < 64; shift += 7 {
if i >= l {
err = io.ErrUnexpectedEOF
return
}
b := p.buf[i]
i++
x |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
p.index = i
return
}
}
// The number is too large to represent in a 64-bit value.
err = errOverflow
return
}
// DecodeVarint reads a varint-encoded integer from the Buffer.
// This is the format for the
// int32, int64, uint32, uint64, bool, and enum
// protocol buffer types.
func (p *Buffer) DecodeVarint() (x uint64, err error) {
i := p.index
buf := p.buf
if i >= len(buf) {
return 0, io.ErrUnexpectedEOF
} else if buf[i] < 0x80 {
p.index++
return uint64(buf[i]), nil
} else if len(buf)-i < 10 {
return p.decodeVarintSlow()
}
var b uint64
// we already checked the first byte
x = uint64(buf[i]) - 0x80
i++
b = uint64(buf[i])
i++
x += b << 7
if b&0x80 == 0 {
goto done
}
x -= 0x80 << 7
b = uint64(buf[i])
i++
x += b << 14
if b&0x80 == 0 {
goto done
}
x -= 0x80 << 14
b = uint64(buf[i])
i++
x += b << 21
if b&0x80 == 0 {
goto done
}
x -= 0x80 << 21
b = uint64(buf[i])
i++
x += b << 28
if b&0x80 == 0 {
goto done
}
x -= 0x80 << 28
b = uint64(buf[i])
i++
x += b << 35
if b&0x80 == 0 {
goto done
}
x -= 0x80 << 35
b = uint64(buf[i])
i++
x += b << 42
if b&0x80 == 0 {
goto done
}
x -= 0x80 << 42
b = uint64(buf[i])
i++
x += b << 49
if b&0x80 == 0 {
goto done
}
x -= 0x80 << 49
b = uint64(buf[i])
i++
x += b << 56
if b&0x80 == 0 {
goto done
}
x -= 0x80 << 56
b = uint64(buf[i])
i++
x += b << 63
if b&0x80 == 0 {
goto done
}
return 0, errOverflow
done:
p.index = i
return x, nil
}
// DecodeFixed64 reads a 64-bit integer from the Buffer.
// This is the format for the
// fixed64, sfixed64, and double protocol buffer types.
func (p *Buffer) DecodeFixed64() (x uint64, err error) {
// x, err already 0
i := p.index + 8
if i < 0 || i > len(p.buf) {
err = io.ErrUnexpectedEOF
return
}
p.index = i
x = uint64(p.buf[i-8])
x |= uint64(p.buf[i-7]) << 8
x |= uint64(p.buf[i-6]) << 16
x |= uint64(p.buf[i-5]) << 24
x |= uint64(p.buf[i-4]) << 32
x |= uint64(p.buf[i-3]) << 40
x |= uint64(p.buf[i-2]) << 48
x |= uint64(p.buf[i-1]) << 56
return
}
// DecodeFixed32 reads a 32-bit integer from the Buffer.
// This is the format for the
// fixed32, sfixed32, and float protocol buffer types.
func (p *Buffer) DecodeFixed32() (x uint64, err error) {
// x, err already 0
i := p.index + 4
if i < 0 || i > len(p.buf) {
err = io.ErrUnexpectedEOF
return
}
p.index = i
x = uint64(p.buf[i-4])
x |= uint64(p.buf[i-3]) << 8
x |= uint64(p.buf[i-2]) << 16
x |= uint64(p.buf[i-1]) << 24
return
}
// DecodeZigzag64 reads a zigzag-encoded 64-bit integer
// from the Buffer.
// This is the format used for the sint64 protocol buffer type.
func (p *Buffer) DecodeZigzag64() (x uint64, err error) {
x, err = p.DecodeVarint()
if err != nil {
return
}
x = (x >> 1) ^ uint64((int64(x&1)<<63)>>63)
return
}
// DecodeZigzag32 reads a zigzag-encoded 32-bit integer
// from the Buffer.
// This is the format used for the sint32 protocol buffer type.
func (p *Buffer) DecodeZigzag32() (x uint64, err error) {
x, err = p.DecodeVarint()
if err != nil {
return
}
x = uint64((uint32(x) >> 1) ^ uint32((int32(x&1)<<31)>>31))
return
}
// DecodeRawBytes reads a count-delimited byte buffer from the Buffer.
// This is the format used for the bytes protocol buffer
// type and for embedded messages.
func (p *Buffer) DecodeRawBytes(alloc bool) (buf []byte, err error) {
n, err := p.DecodeVarint()
if err != nil {
return nil, err
}
nb := int(n)
if nb < 0 {
return nil, fmt.Errorf("proto: bad byte length %d", nb)
}
end := p.index + nb
if end < p.index || end > len(p.buf) {
return nil, io.ErrUnexpectedEOF
}
if !alloc {
// todo: check if can get more uses of alloc=false
buf = p.buf[p.index:end]
p.index += nb
return
}
buf = make([]byte, nb)
copy(buf, p.buf[p.index:])
p.index += nb
return
}
// DecodeStringBytes reads an encoded string from the Buffer.
// This is the format used for the proto2 string type.
func (p *Buffer) DecodeStringBytes() (s string, err error) {
buf, err := p.DecodeRawBytes(false)
if err != nil {
return
}
return string(buf), nil
}
// Unmarshaler is the interface representing objects that can
// unmarshal themselves. The argument points to data that may be
// overwritten, so implementations should not keep references to the
// buffer.
// Unmarshal implementations should not clear the receiver.
// Any unmarshaled data should be merged into the receiver.
// Callers of Unmarshal that do not want to retain existing data
// should Reset the receiver before calling Unmarshal.
type Unmarshaler interface {
Unmarshal([]byte) error
}
// newUnmarshaler is the interface representing objects that can
// unmarshal themselves. The semantics are identical to Unmarshaler.
//
// This exists to support protoc-gen-go generated messages.
// The proto package will stop type-asserting to this interface in the future.
//
// DO NOT DEPEND ON THIS.
type newUnmarshaler interface {
XXX_Unmarshal([]byte) error
}
// Unmarshal parses the protocol buffer representation in buf and places the
// decoded result in pb. If the struct underlying pb does not match
// the data in buf, the results can be unpredictable.
//
// Unmarshal resets pb before starting to unmarshal, so any
// existing data in pb is always removed. Use UnmarshalMerge
// to preserve and append to existing data.
func Unmarshal(buf []byte, pb Message) error {
pb.Reset()
if u, ok := pb.(newUnmarshaler); ok {
return u.XXX_Unmarshal(buf)
}
if u, ok := pb.(Unmarshaler); ok {
return u.Unmarshal(buf)
}
return NewBuffer(buf).Unmarshal(pb)
}
// UnmarshalMerge parses the protocol buffer representation in buf and
// writes the decoded result to pb. If the struct underlying pb does not match
// the data in buf, the results can be unpredictable.
//
// UnmarshalMerge merges into existing data in pb.
// Most code should use Unmarshal instead.
func UnmarshalMerge(buf []byte, pb Message) error {
if u, ok := pb.(newUnmarshaler); ok {
return u.XXX_Unmarshal(buf)
}
if u, ok := pb.(Unmarshaler); ok {
// NOTE: The history of proto have unfortunately been inconsistent
// whether Unmarshaler should or should not implicitly clear itself.
// Some implementations do, most do not.
// Thus, calling this here may or may not do what people want.
//
// See https://github.com/golang/protobuf/issues/424
return u.Unmarshal(buf)
}
return NewBuffer(buf).Unmarshal(pb)
}
// DecodeMessage reads a count-delimited message from the Buffer.
func (p *Buffer) DecodeMessage(pb Message) error {
enc, err := p.DecodeRawBytes(false)
if err != nil {
return err
}
return NewBuffer(enc).Unmarshal(pb)
}
// DecodeGroup reads a tag-delimited group from the Buffer.
// StartGroup tag is already consumed. This function consumes
// EndGroup tag.
func (p *Buffer) DecodeGroup(pb Message) error {
b := p.buf[p.index:]
x, y := findEndGroup(b)
if x < 0 {
return io.ErrUnexpectedEOF
}
err := Unmarshal(b[:x], pb)
p.index += y
return err
}
// Unmarshal parses the protocol buffer representation in the
// Buffer and places the decoded result in pb. If the struct
// underlying pb does not match the data in the buffer, the results can be
// unpredictable.
//
// Unlike proto.Unmarshal, this does not reset pb before starting to unmarshal.
func (p *Buffer) Unmarshal(pb Message) error {
// If the object can unmarshal itself, let it.
if u, ok := pb.(newUnmarshaler); ok {
err := u.XXX_Unmarshal(p.buf[p.index:])
p.index = len(p.buf)
return err
}
if u, ok := pb.(Unmarshaler); ok {
// NOTE: The history of proto have unfortunately been inconsistent
// whether Unmarshaler should or should not implicitly clear itself.
// Some implementations do, most do not.
// Thus, calling this here may or may not do what people want.
//
// See https://github.com/golang/protobuf/issues/424
err := u.Unmarshal(p.buf[p.index:])
p.index = len(p.buf)
return err
}
// Slow workaround for messages that aren't Unmarshalers.
// This includes some hand-coded .pb.go files and
// bootstrap protos.
// TODO: fix all of those and then add Unmarshal to
// the Message interface. Then:
// The cast above and code below can be deleted.
// The old unmarshaler can be deleted.
// Clients can call Unmarshal directly (can already do that, actually).
var info InternalMessageInfo
err := info.Unmarshal(pb, p.buf[p.index:])
p.index = len(p.buf)
return err
}

63
vendor/github.com/golang/protobuf/proto/defaults.go generated vendored Normal file
View file

@ -0,0 +1,63 @@
// Copyright 2019 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
package proto
import (
"google.golang.org/protobuf/reflect/protoreflect"
)
// SetDefaults sets unpopulated scalar fields to their default values.
// Fields within a oneof are not set even if they have a default value.
// SetDefaults is recursively called upon any populated message fields.
func SetDefaults(m Message) {
if m != nil {
setDefaults(MessageReflect(m))
}
}
func setDefaults(m protoreflect.Message) {
fds := m.Descriptor().Fields()
for i := 0; i < fds.Len(); i++ {
fd := fds.Get(i)
if !m.Has(fd) {
if fd.HasDefault() && fd.ContainingOneof() == nil {
v := fd.Default()
if fd.Kind() == protoreflect.BytesKind {
v = protoreflect.ValueOf(append([]byte(nil), v.Bytes()...)) // copy the default bytes
}
m.Set(fd, v)
}
continue
}
}
m.Range(func(fd protoreflect.FieldDescriptor, v protoreflect.Value) bool {
switch {
// Handle singular message.
case fd.Cardinality() != protoreflect.Repeated:
if fd.Message() != nil {
setDefaults(m.Get(fd).Message())
}
// Handle list of messages.
case fd.IsList():
if fd.Message() != nil {
ls := m.Get(fd).List()
for i := 0; i < ls.Len(); i++ {
setDefaults(ls.Get(i).Message())
}
}
// Handle map of messages.
case fd.IsMap():
if fd.MapValue().Message() != nil {
ms := m.Get(fd).Map()
ms.Range(func(_ protoreflect.MapKey, v protoreflect.Value) bool {
setDefaults(v.Message())
return true
})
}
}
return true
})
}

126
vendor/github.com/golang/protobuf/proto/deprecated.go generated vendored
View file

@ -1,63 +1,113 @@
// Go support for Protocol Buffers - Google's data interchange format
//
// Copyright 2018 The Go Authors. All rights reserved.
// https://github.com/golang/protobuf
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
// * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
// * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following disclaimer
// in the documentation and/or other materials provided with the
// distribution.
// * Neither the name of Google Inc. nor the names of its
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
// Copyright 2018 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
package proto
import "errors"
import (
"encoding/json"
"errors"
"fmt"
"strconv"
// Deprecated: do not use.
protoV2 "google.golang.org/protobuf/proto"
)
var (
// Deprecated: No longer returned.
ErrNil = errors.New("proto: Marshal called with nil")
// Deprecated: No longer returned.
ErrTooLarge = errors.New("proto: message encodes to over 2 GB")
// Deprecated: No longer returned.
ErrInternalBadWireType = errors.New("proto: internal error: bad wiretype for oneof")
)
// Deprecated: Do not use.
type Stats struct{ Emalloc, Dmalloc, Encode, Decode, Chit, Cmiss, Size uint64 }
// Deprecated: do not use.
// Deprecated: Do not use.
func GetStats() Stats { return Stats{} }
// Deprecated: do not use.
// Deprecated: Do not use.
func MarshalMessageSet(interface{}) ([]byte, error) {
return nil, errors.New("proto: not implemented")
}
// Deprecated: do not use.
// Deprecated: Do not use.
func UnmarshalMessageSet([]byte, interface{}) error {
return errors.New("proto: not implemented")
}
// Deprecated: do not use.
// Deprecated: Do not use.
func MarshalMessageSetJSON(interface{}) ([]byte, error) {
return nil, errors.New("proto: not implemented")
}
// Deprecated: do not use.
// Deprecated: Do not use.
func UnmarshalMessageSetJSON([]byte, interface{}) error {
return errors.New("proto: not implemented")
}
// Deprecated: do not use.
// Deprecated: Do not use.
func RegisterMessageSetType(Message, int32, string) {}
// Deprecated: Do not use.
func EnumName(m map[int32]string, v int32) string {
s, ok := m[v]
if ok {
return s
}
return strconv.Itoa(int(v))
}
// Deprecated: Do not use.
func UnmarshalJSONEnum(m map[string]int32, data []byte, enumName string) (int32, error) {
if data[0] == '"' {
// New style: enums are strings.
var repr string
if err := json.Unmarshal(data, &repr); err != nil {
return -1, err
}
val, ok := m[repr]
if !ok {
return 0, fmt.Errorf("unrecognized enum %s value %q", enumName, repr)
}
return val, nil
}
// Old style: enums are ints.
var val int32
if err := json.Unmarshal(data, &val); err != nil {
return 0, fmt.Errorf("cannot unmarshal %#q into enum %s", data, enumName)
}
return val, nil
}
// Deprecated: Do not use; this type existed for intenal-use only.
type InternalMessageInfo struct{}
// Deprecated: Do not use; this method existed for intenal-use only.
func (*InternalMessageInfo) DiscardUnknown(m Message) {
DiscardUnknown(m)
}
// Deprecated: Do not use; this method existed for intenal-use only.
func (*InternalMessageInfo) Marshal(b []byte, m Message, deterministic bool) ([]byte, error) {
return protoV2.MarshalOptions{Deterministic: deterministic}.MarshalAppend(b, MessageV2(m))
}
// Deprecated: Do not use; this method existed for intenal-use only.
func (*InternalMessageInfo) Merge(dst, src Message) {
protoV2.Merge(MessageV2(dst), MessageV2(src))
}
// Deprecated: Do not use; this method existed for intenal-use only.
func (*InternalMessageInfo) Size(m Message) int {
return protoV2.Size(MessageV2(m))
}
// Deprecated: Do not use; this method existed for intenal-use only.
func (*InternalMessageInfo) Unmarshal(m Message, b []byte) error {
return protoV2.UnmarshalOptions{Merge: true}.Unmarshal(b, MessageV2(m))
}

356
vendor/github.com/golang/protobuf/proto/discard.go generated vendored
View file

@ -1,48 +1,13 @@
// Go support for Protocol Buffers - Google's data interchange format
//
// Copyright 2017 The Go Authors. All rights reserved.
// https://github.com/golang/protobuf
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
// * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
// * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following disclaimer
// in the documentation and/or other materials provided with the
// distribution.
// * Neither the name of Google Inc. nor the names of its
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
// Copyright 2019 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
package proto
import (
"fmt"
"reflect"
"strings"
"sync"
"sync/atomic"
"google.golang.org/protobuf/reflect/protoreflect"
)
type generatedDiscarder interface {
XXX_DiscardUnknown()
}
// DiscardUnknown recursively discards all unknown fields from this message
// and all embedded messages.
//
@ -51,300 +16,43 @@ type generatedDiscarder interface {
// marshal to be able to produce a message that continues to have those
// unrecognized fields. To avoid this, DiscardUnknown is used to
// explicitly clear the unknown fields after unmarshaling.
//
// For proto2 messages, the unknown fields of message extensions are only
// discarded from messages that have been accessed via GetExtension.
func DiscardUnknown(m Message) {
if m, ok := m.(generatedDiscarder); ok {
m.XXX_DiscardUnknown()
return
if m != nil {
discardUnknown(MessageReflect(m))
}
// TODO: Dynamically populate a InternalMessageInfo for legacy messages,
// but the master branch has no implementation for InternalMessageInfo,
// so it would be more work to replicate that approach.
discardLegacy(m)
}
// DiscardUnknown recursively discards all unknown fields.
func (a *InternalMessageInfo) DiscardUnknown(m Message) {
di := atomicLoadDiscardInfo(&a.discard)
if di == nil {
di = getDiscardInfo(reflect.TypeOf(m).Elem())
atomicStoreDiscardInfo(&a.discard, di)
}
di.discard(toPointer(&m))
}
type discardInfo struct {
typ reflect.Type
initialized int32 // 0: only typ is valid, 1: everything is valid
lock sync.Mutex
fields []discardFieldInfo
unrecognized field
}
type discardFieldInfo struct {
field field // Offset of field, guaranteed to be valid
discard func(src pointer)
}
var (
discardInfoMap = map[reflect.Type]*discardInfo{}
discardInfoLock sync.Mutex
)
func getDiscardInfo(t reflect.Type) *discardInfo {
discardInfoLock.Lock()
defer discardInfoLock.Unlock()
di := discardInfoMap[t]
if di == nil {
di = &discardInfo{typ: t}
discardInfoMap[t] = di
}
return di
}
func (di *discardInfo) discard(src pointer) {
if src.isNil() {
return // Nothing to do.
}
if atomic.LoadInt32(&di.initialized) == 0 {
di.computeDiscardInfo()
}
for _, fi := range di.fields {
sfp := src.offset(fi.field)
fi.discard(sfp)
}
// For proto2 messages, only discard unknown fields in message extensions
// that have been accessed via GetExtension.
if em, err := extendable(src.asPointerTo(di.typ).Interface()); err == nil {
// Ignore lock since DiscardUnknown is not concurrency safe.
emm, _ := em.extensionsRead()
for _, mx := range emm {
if m, ok := mx.value.(Message); ok {
DiscardUnknown(m)
func discardUnknown(m protoreflect.Message) {
m.Range(func(fd protoreflect.FieldDescriptor, val protoreflect.Value) bool {
switch {
// Handle singular message.
case fd.Cardinality() != protoreflect.Repeated:
if fd.Message() != nil {
discardUnknown(m.Get(fd).Message())
}
}
}
if di.unrecognized.IsValid() {
*src.offset(di.unrecognized).toBytes() = nil
}
}
func (di *discardInfo) computeDiscardInfo() {
di.lock.Lock()
defer di.lock.Unlock()
if di.initialized != 0 {
return
}
t := di.typ
n := t.NumField()
for i := 0; i < n; i++ {
f := t.Field(i)
if strings.HasPrefix(f.Name, "XXX_") {
continue
}
dfi := discardFieldInfo{field: toField(&f)}
tf := f.Type
// Unwrap tf to get its most basic type.
var isPointer, isSlice bool
if tf.Kind() == reflect.Slice && tf.Elem().Kind() != reflect.Uint8 {
isSlice = true
tf = tf.Elem()
}
if tf.Kind() == reflect.Ptr {
isPointer = true
tf = tf.Elem()
}
if isPointer && isSlice && tf.Kind() != reflect.Struct {
panic(fmt.Sprintf("%v.%s cannot be a slice of pointers to primitive types", t, f.Name))
}
switch tf.Kind() {
case reflect.Struct:
switch {
case !isPointer:
panic(fmt.Sprintf("%v.%s cannot be a direct struct value", t, f.Name))
case isSlice: // E.g., []*pb.T
di := getDiscardInfo(tf)
dfi.discard = func(src pointer) {
sps := src.getPointerSlice()
for _, sp := range sps {
if !sp.isNil() {
di.discard(sp)
}
}
}
default: // E.g., *pb.T
di := getDiscardInfo(tf)
dfi.discard = func(src pointer) {
sp := src.getPointer()
if !sp.isNil() {
di.discard(sp)
}
// Handle list of messages.
case fd.IsList():
if fd.Message() != nil {
ls := m.Get(fd).List()
for i := 0; i < ls.Len(); i++ {
discardUnknown(ls.Get(i).Message())
}
}
case reflect.Map:
switch {
case isPointer || isSlice:
panic(fmt.Sprintf("%v.%s cannot be a pointer to a map or a slice of map values", t, f.Name))
default: // E.g., map[K]V
if tf.Elem().Kind() == reflect.Ptr { // Proto struct (e.g., *T)
dfi.discard = func(src pointer) {
sm := src.asPointerTo(tf).Elem()
if sm.Len() == 0 {
return
}
for _, key := range sm.MapKeys() {
val := sm.MapIndex(key)
DiscardUnknown(val.Interface().(Message))
}
}
} else {
dfi.discard = func(pointer) {} // Noop
}
}
case reflect.Interface:
// Must be oneof field.
switch {
case isPointer || isSlice:
panic(fmt.Sprintf("%v.%s cannot be a pointer to a interface or a slice of interface values", t, f.Name))
default: // E.g., interface{}
// TODO: Make this faster?
dfi.discard = func(src pointer) {
su := src.asPointerTo(tf).Elem()
if !su.IsNil() {
sv := su.Elem().Elem().Field(0)
if sv.Kind() == reflect.Ptr && sv.IsNil() {
return
}
switch sv.Type().Kind() {
case reflect.Ptr: // Proto struct (e.g., *T)
DiscardUnknown(sv.Interface().(Message))
}
}
}
}
default:
continue
}
di.fields = append(di.fields, dfi)
}
di.unrecognized = invalidField
if f, ok := t.FieldByName("XXX_unrecognized"); ok {
if f.Type != reflect.TypeOf([]byte{}) {
panic("expected XXX_unrecognized to be of type []byte")
}
di.unrecognized = toField(&f)
}
atomic.StoreInt32(&di.initialized, 1)
}
func discardLegacy(m Message) {
v := reflect.ValueOf(m)
if v.Kind() != reflect.Ptr || v.IsNil() {
return
}
v = v.Elem()
if v.Kind() != reflect.Struct {
return
}
t := v.Type()
for i := 0; i < v.NumField(); i++ {
f := t.Field(i)
if strings.HasPrefix(f.Name, "XXX_") {
continue
}
vf := v.Field(i)
tf := f.Type
// Unwrap tf to get its most basic type.
var isPointer, isSlice bool
if tf.Kind() == reflect.Slice && tf.Elem().Kind() != reflect.Uint8 {
isSlice = true
tf = tf.Elem()
}
if tf.Kind() == reflect.Ptr {
isPointer = true
tf = tf.Elem()
}
if isPointer && isSlice && tf.Kind() != reflect.Struct {
panic(fmt.Sprintf("%T.%s cannot be a slice of pointers to primitive types", m, f.Name))
}
switch tf.Kind() {
case reflect.Struct:
switch {
case !isPointer:
panic(fmt.Sprintf("%T.%s cannot be a direct struct value", m, f.Name))
case isSlice: // E.g., []*pb.T
for j := 0; j < vf.Len(); j++ {
discardLegacy(vf.Index(j).Interface().(Message))
}
default: // E.g., *pb.T
discardLegacy(vf.Interface().(Message))
}
case reflect.Map:
switch {
case isPointer || isSlice:
panic(fmt.Sprintf("%T.%s cannot be a pointer to a map or a slice of map values", m, f.Name))
default: // E.g., map[K]V
tv := vf.Type().Elem()
if tv.Kind() == reflect.Ptr && tv.Implements(protoMessageType) { // Proto struct (e.g., *T)
for _, key := range vf.MapKeys() {
val := vf.MapIndex(key)
discardLegacy(val.Interface().(Message))
}
}
}
case reflect.Interface:
// Must be oneof field.
switch {
case isPointer || isSlice:
panic(fmt.Sprintf("%T.%s cannot be a pointer to a interface or a slice of interface values", m, f.Name))
default: // E.g., test_proto.isCommunique_Union interface
if !vf.IsNil() && f.Tag.Get("protobuf_oneof") != "" {
vf = vf.Elem() // E.g., *test_proto.Communique_Msg
if !vf.IsNil() {
vf = vf.Elem() // E.g., test_proto.Communique_Msg
vf = vf.Field(0) // E.g., Proto struct (e.g., *T) or primitive value
if vf.Kind() == reflect.Ptr {
discardLegacy(vf.Interface().(Message))
}
}
}
// Handle map of messages.
case fd.IsMap():
if fd.MapValue().Message() != nil {
ms := m.Get(fd).Map()
ms.Range(func(_ protoreflect.MapKey, v protoreflect.Value) bool {
discardUnknown(v.Message())
return true
})
}
}
}
return true
})
if vf := v.FieldByName("XXX_unrecognized"); vf.IsValid() {
if vf.Type() != reflect.TypeOf([]byte{}) {
panic("expected XXX_unrecognized to be of type []byte")
}
vf.Set(reflect.ValueOf([]byte(nil)))
}
// For proto2 messages, only discard unknown fields in message extensions
// that have been accessed via GetExtension.
if em, err := extendable(m); err == nil {
// Ignore lock since discardLegacy is not concurrency safe.
emm, _ := em.extensionsRead()
for _, mx := range emm {
if m, ok := mx.value.(Message); ok {
discardLegacy(m)
}
}
// Discard unknown fields.
if len(m.GetUnknown()) > 0 {
m.SetUnknown(nil)
}
}

203
vendor/github.com/golang/protobuf/proto/encode.go generated vendored
View file

@ -1,203 +0,0 @@
// Go support for Protocol Buffers - Google's data interchange format
//
// Copyright 2010 The Go Authors. All rights reserved.
// https://github.com/golang/protobuf
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
// * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
// * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following disclaimer
// in the documentation and/or other materials provided with the
// distribution.
// * Neither the name of Google Inc. nor the names of its
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
package proto
/*
* Routines for encoding data into the wire format for protocol buffers.
*/
import (
"errors"
"reflect"
)
var (
// errRepeatedHasNil is the error returned if Marshal is called with
// a struct with a repeated field containing a nil element.
errRepeatedHasNil = errors.New("proto: repeated field has nil element")
// errOneofHasNil is the error returned if Marshal is called with
// a struct with a oneof field containing a nil element.
errOneofHasNil = errors.New("proto: oneof field has nil value")
// ErrNil is the error returned if Marshal is called with nil.
ErrNil = errors.New("proto: Marshal called with nil")
// ErrTooLarge is the error returned if Marshal is called with a
// message that encodes to >2GB.
ErrTooLarge = errors.New("proto: message encodes to over 2 GB")
)
// The fundamental encoders that put bytes on the wire.
// Those that take integer types all accept uint64 and are
// therefore of type valueEncoder.
const maxVarintBytes = 10 // maximum length of a varint
// EncodeVarint returns the varint encoding of x.
// This is the format for the
// int32, int64, uint32, uint64, bool, and enum
// protocol buffer types.
// Not used by the package itself, but helpful to clients
// wishing to use the same encoding.
func EncodeVarint(x uint64) []byte {
var buf [maxVarintBytes]byte
var n int
for n = 0; x > 127; n++ {
buf[n] = 0x80 | uint8(x&0x7F)
x >>= 7
}
buf[n] = uint8(x)
n++
return buf[0:n]
}
// EncodeVarint writes a varint-encoded integer to the Buffer.
// This is the format for the
// int32, int64, uint32, uint64, bool, and enum
// protocol buffer types.
func (p *Buffer) EncodeVarint(x uint64) error {
for x >= 1<<7 {
p.buf = append(p.buf, uint8(x&0x7f|0x80))
x >>= 7
}
p.buf = append(p.buf, uint8(x))
return nil
}
// SizeVarint returns the varint encoding size of an integer.
func SizeVarint(x uint64) int {
switch {
case x < 1<<7:
return 1
case x < 1<<14:
return 2
case x < 1<<21:
return 3
case x < 1<<28:
return 4
case x < 1<<35:
return 5
case x < 1<<42:
return 6
case x < 1<<49:
return 7
case x < 1<<56:
return 8
case x < 1<<63:
return 9
}
return 10
}
// EncodeFixed64 writes a 64-bit integer to the Buffer.
// This is the format for the
// fixed64, sfixed64, and double protocol buffer types.
func (p *Buffer) EncodeFixed64(x uint64) error {
p.buf = append(p.buf,
uint8(x),
uint8(x>>8),
uint8(x>>16),
uint8(x>>24),
uint8(x>>32),
uint8(x>>40),
uint8(x>>48),
uint8(x>>56))
return nil
}
// EncodeFixed32 writes a 32-bit integer to the Buffer.
// This is the format for the
// fixed32, sfixed32, and float protocol buffer types.
func (p *Buffer) EncodeFixed32(x uint64) error {
p.buf = append(p.buf,
uint8(x),
uint8(x>>8),
uint8(x>>16),
uint8(x>>24))
return nil
}
// EncodeZigzag64 writes a zigzag-encoded 64-bit integer
// to the Buffer.
// This is the format used for the sint64 protocol buffer type.
func (p *Buffer) EncodeZigzag64(x uint64) error {
// use signed number to get arithmetic right shift.
return p.EncodeVarint(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
// EncodeZigzag32 writes a zigzag-encoded 32-bit integer
// to the Buffer.
// This is the format used for the sint32 protocol buffer type.
func (p *Buffer) EncodeZigzag32(x uint64) error {
// use signed number to get arithmetic right shift.
return p.EncodeVarint(uint64((uint32(x) << 1) ^ uint32((int32(x) >> 31))))
}
// EncodeRawBytes writes a count-delimited byte buffer to the Buffer.
// This is the format used for the bytes protocol buffer
// type and for embedded messages.
func (p *Buffer) EncodeRawBytes(b []byte) error {
p.EncodeVarint(uint64(len(b)))
p.buf = append(p.buf, b...)
return nil
}
// EncodeStringBytes writes an encoded string to the Buffer.
// This is the format used for the proto2 string type.
func (p *Buffer) EncodeStringBytes(s string) error {
p.EncodeVarint(uint64(len(s)))
p.buf = append(p.buf, s...)
return nil
}
// Marshaler is the interface representing objects that can marshal themselves.
type Marshaler interface {
Marshal() ([]byte, error)
}
// EncodeMessage writes the protocol buffer to the Buffer,
// prefixed by a varint-encoded length.
func (p *Buffer) EncodeMessage(pb Message) error {
siz := Size(pb)
p.EncodeVarint(uint64(siz))
return p.Marshal(pb)
}
// All protocol buffer fields are nillable, but be careful.
func isNil(v reflect.Value) bool {
switch v.Kind() {
case reflect.Interface, reflect.Map, reflect.Ptr, reflect.Slice:
return v.IsNil()
}
return false
}

301
vendor/github.com/golang/protobuf/proto/equal.go generated vendored
View file

@ -1,301 +0,0 @@
// Go support for Protocol Buffers - Google's data interchange format
//
// Copyright 2011 The Go Authors. All rights reserved.
// https://github.com/golang/protobuf
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
// * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
// * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following disclaimer
// in the documentation and/or other materials provided with the
// distribution.
// * Neither the name of Google Inc. nor the names of its
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
// Protocol buffer comparison.
package proto
import (
"bytes"
"log"
"reflect"
"strings"
)
/*
Equal returns true iff protocol buffers a and b are equal.
The arguments must both be pointers to protocol buffer structs.
Equality is defined in this way:
- Two messages are equal iff they are the same type,
corresponding fields are equal, unknown field sets
are equal, and extensions sets are equal.
- Two set scalar fields are equal iff their values are equal.
If the fields are of a floating-point type, remember that
NaN != x for all x, including NaN. If the message is defined
in a proto3 .proto file, fields are not "set"; specifically,
zero length proto3 "bytes" fields are equal (nil == {}).
- Two repeated fields are equal iff their lengths are the same,
and their corresponding elements are equal. Note a "bytes" field,
although represented by []byte, is not a repeated field and the
rule for the scalar fields described above applies.
- Two unset fields are equal.
- Two unknown field sets are equal if their current
encoded state is equal.
- Two extension sets are equal iff they have corresponding
elements that are pairwise equal.
- Two map fields are equal iff their lengths are the same,
and they contain the same set of elements. Zero-length map
fields are equal.
- Every other combination of things are not equal.
The return value is undefined if a and b are not protocol buffers.
*/
func Equal(a, b Message) bool {
if a == nil || b == nil {
return a == b
}
v1, v2 := reflect.ValueOf(a), reflect.ValueOf(b)
if v1.Type() != v2.Type() {
return false
}
if v1.Kind() == reflect.Ptr {
if v1.IsNil() {
return v2.IsNil()
}
if v2.IsNil() {
return false
}
v1, v2 = v1.Elem(), v2.Elem()
}
if v1.Kind() != reflect.Struct {
return false
}
return equalStruct(v1, v2)
}
// v1 and v2 are known to have the same type.
func equalStruct(v1, v2 reflect.Value) bool {
sprop := GetProperties(v1.Type())
for i := 0; i < v1.NumField(); i++ {
f := v1.Type().Field(i)
if strings.HasPrefix(f.Name, "XXX_") {
continue
}
f1, f2 := v1.Field(i), v2.Field(i)
if f.Type.Kind() == reflect.Ptr {
if n1, n2 := f1.IsNil(), f2.IsNil(); n1 && n2 {
// both unset
continue
} else if n1 != n2 {
// set/unset mismatch
return false
}
f1, f2 = f1.Elem(), f2.Elem()
}
if !equalAny(f1, f2, sprop.Prop[i]) {
return false
}
}
if em1 := v1.FieldByName("XXX_InternalExtensions"); em1.IsValid() {
em2 := v2.FieldByName("XXX_InternalExtensions")
if !equalExtensions(v1.Type(), em1.Interface().(XXX_InternalExtensions), em2.Interface().(XXX_InternalExtensions)) {
return false
}
}
if em1 := v1.FieldByName("XXX_extensions"); em1.IsValid() {
em2 := v2.FieldByName("XXX_extensions")
if !equalExtMap(v1.Type(), em1.Interface().(map[int32]Extension), em2.Interface().(map[int32]Extension)) {
return false
}
}
uf := v1.FieldByName("XXX_unrecognized")
if !uf.IsValid() {
return true
}
u1 := uf.Bytes()
u2 := v2.FieldByName("XXX_unrecognized").Bytes()
return bytes.Equal(u1, u2)
}
// v1 and v2 are known to have the same type.
// prop may be nil.
func equalAny(v1, v2 reflect.Value, prop *Properties) bool {
if v1.Type() == protoMessageType {
m1, _ := v1.Interface().(Message)
m2, _ := v2.Interface().(Message)
return Equal(m1, m2)
}
switch v1.Kind() {
case reflect.Bool:
return v1.Bool() == v2.Bool()
case reflect.Float32, reflect.Float64:
return v1.Float() == v2.Float()
case reflect.Int32, reflect.Int64:
return v1.Int() == v2.Int()
case reflect.Interface:
// Probably a oneof field; compare the inner values.
n1, n2 := v1.IsNil(), v2.IsNil()
if n1 || n2 {
return n1 == n2
}
e1, e2 := v1.Elem(), v2.Elem()
if e1.Type() != e2.Type() {
return false
}
return equalAny(e1, e2, nil)
case reflect.Map:
if v1.Len() != v2.Len() {
return false
}
for _, key := range v1.MapKeys() {
val2 := v2.MapIndex(key)
if !val2.IsValid() {
// This key was not found in the second map.
return false
}
if !equalAny(v1.MapIndex(key), val2, nil) {
return false
}
}
return true
case reflect.Ptr:
// Maps may have nil values in them, so check for nil.
if v1.IsNil() && v2.IsNil() {
return true
}
if v1.IsNil() != v2.IsNil() {
return false
}
return equalAny(v1.Elem(), v2.Elem(), prop)
case reflect.Slice:
if v1.Type().Elem().Kind() == reflect.Uint8 {
// short circuit: []byte
// Edge case: if this is in a proto3 message, a zero length
// bytes field is considered the zero value.
if prop != nil && prop.proto3 && v1.Len() == 0 && v2.Len() == 0 {
return true
}
if v1.IsNil() != v2.IsNil() {
return false
}
return bytes.Equal(v1.Interface().([]byte), v2.Interface().([]byte))
}
if v1.Len() != v2.Len() {
return false
}
for i := 0; i < v1.Len(); i++ {
if !equalAny(v1.Index(i), v2.Index(i), prop) {
return false
}
}
return true
case reflect.String:
return v1.Interface().(string) == v2.Interface().(string)
case reflect.Struct:
return equalStruct(v1, v2)
case reflect.Uint32, reflect.Uint64:
return v1.Uint() == v2.Uint()
}
// unknown type, so not a protocol buffer
log.Printf("proto: don't know how to compare %v", v1)
return false
}
// base is the struct type that the extensions are based on.
// x1 and x2 are InternalExtensions.
func equalExtensions(base reflect.Type, x1, x2 XXX_InternalExtensions) bool {
em1, _ := x1.extensionsRead()
em2, _ := x2.extensionsRead()
return equalExtMap(base, em1, em2)
}
func equalExtMap(base reflect.Type, em1, em2 map[int32]Extension) bool {
if len(em1) != len(em2) {
return false
}
for extNum, e1 := range em1 {
e2, ok := em2[extNum]
if !ok {
return false
}
m1 := extensionAsLegacyType(e1.value)
m2 := extensionAsLegacyType(e2.value)
if m1 == nil && m2 == nil {
// Both have only encoded form.
if bytes.Equal(e1.enc, e2.enc) {
continue
}
// The bytes are different, but the extensions might still be
// equal. We need to decode them to compare.
}
if m1 != nil && m2 != nil {
// Both are unencoded.
if !equalAny(reflect.ValueOf(m1), reflect.ValueOf(m2), nil) {
return false
}
continue
}
// At least one is encoded. To do a semantically correct comparison
// we need to unmarshal them first.
var desc *ExtensionDesc
if m := extensionMaps[base]; m != nil {
desc = m[extNum]
}
if desc == nil {
// If both have only encoded form and the bytes are the same,
// it is handled above. We get here when the bytes are different.
// We don't know how to decode it, so just compare them as byte
// slices.
log.Printf("proto: don't know how to compare extension %d of %v", extNum, base)
return false
}
var err error
if m1 == nil {
m1, err = decodeExtension(e1.enc, desc)
}
if m2 == nil && err == nil {
m2, err = decodeExtension(e2.enc, desc)
}
if err != nil {
// The encoded form is invalid.
log.Printf("proto: badly encoded extension %d of %v: %v", extNum, base, err)
return false
}
if !equalAny(reflect.ValueOf(m1), reflect.ValueOf(m2), nil) {
return false
}
}
return true
}

845
vendor/github.com/golang/protobuf/proto/extensions.go generated vendored
View file

@ -1,607 +1,356 @@
// Go support for Protocol Buffers - Google's data interchange format
//
// Copyright 2010 The Go Authors. All rights reserved.
// https://github.com/golang/protobuf
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
// * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
// * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following disclaimer
// in the documentation and/or other materials provided with the
// distribution.
// * Neither the name of Google Inc. nor the names of its
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
// Copyright 2010 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
package proto
/*
* Types and routines for supporting protocol buffer extensions.
*/
import (
"errors"
"fmt"
"io"
"reflect"
"strconv"
"sync"
"google.golang.org/protobuf/encoding/protowire"
"google.golang.org/protobuf/proto"
"google.golang.org/protobuf/reflect/protoreflect"
"google.golang.org/protobuf/reflect/protoregistry"
"google.golang.org/protobuf/runtime/protoiface"
"google.golang.org/protobuf/runtime/protoimpl"
)
// ErrMissingExtension is the error returned by GetExtension if the named extension is not in the message.
type (
// ExtensionDesc represents an extension descriptor and
// is used to interact with an extension field in a message.
//
// Variables of this type are generated in code by protoc-gen-go.
ExtensionDesc = protoimpl.ExtensionInfo
// ExtensionRange represents a range of message extensions.
// Used in code generated by protoc-gen-go.
ExtensionRange = protoiface.ExtensionRangeV1
// Deprecated: Do not use; this is an internal type.
Extension = protoimpl.ExtensionFieldV1
// Deprecated: Do not use; this is an internal type.
XXX_InternalExtensions = protoimpl.ExtensionFields
)
// ErrMissingExtension reports whether the extension was not present.
var ErrMissingExtension = errors.New("proto: missing extension")
// ExtensionRange represents a range of message extensions for a protocol buffer.
// Used in code generated by the protocol compiler.
type ExtensionRange struct {
Start, End int32 // both inclusive
}
// extendableProto is an interface implemented by any protocol buffer generated by the current
// proto compiler that may be extended.
type extendableProto interface {
Message
ExtensionRangeArray() []ExtensionRange
extensionsWrite() map[int32]Extension
extensionsRead() (map[int32]Extension, sync.Locker)
}
// extendableProtoV1 is an interface implemented by a protocol buffer generated by the previous
// version of the proto compiler that may be extended.
type extendableProtoV1 interface {
Message
ExtensionRangeArray() []ExtensionRange
ExtensionMap() map[int32]Extension
}
// extensionAdapter is a wrapper around extendableProtoV1 that implements extendableProto.
type extensionAdapter struct {
extendableProtoV1
}
func (e extensionAdapter) extensionsWrite() map[int32]Extension {
return e.ExtensionMap()
}
func (e extensionAdapter) extensionsRead() (map[int32]Extension, sync.Locker) {
return e.ExtensionMap(), notLocker{}
}
// notLocker is a sync.Locker whose Lock and Unlock methods are nops.
type notLocker struct{}
func (n notLocker) Lock() {}
func (n notLocker) Unlock() {}
// extendable returns the extendableProto interface for the given generated proto message.
// If the proto message has the old extension format, it returns a wrapper that implements
// the extendableProto interface.
func extendable(p interface{}) (extendableProto, error) {
switch p := p.(type) {
case extendableProto:
if isNilPtr(p) {
return nil, fmt.Errorf("proto: nil %T is not extendable", p)
}
return p, nil
case extendableProtoV1:
if isNilPtr(p) {
return nil, fmt.Errorf("proto: nil %T is not extendable", p)
}
return extensionAdapter{p}, nil
}
// Don't allocate a specific error containing %T:
// this is the hot path for Clone and MarshalText.
return nil, errNotExtendable
}
var errNotExtendable = errors.New("proto: not an extendable proto.Message")
func isNilPtr(x interface{}) bool {
v := reflect.ValueOf(x)
return v.Kind() == reflect.Ptr && v.IsNil()
}
// XXX_InternalExtensions is an internal representation of proto extensions.
//
// Each generated message struct type embeds an anonymous XXX_InternalExtensions field,
// thus gaining the unexported 'extensions' method, which can be called only from the proto package.
//
// The methods of XXX_InternalExtensions are not concurrency safe in general,
// but calls to logically read-only methods such as has and get may be executed concurrently.
type XXX_InternalExtensions struct {
// The struct must be indirect so that if a user inadvertently copies a
// generated message and its embedded XXX_InternalExtensions, they
// avoid the mayhem of a copied mutex.
//
// The mutex serializes all logically read-only operations to p.extensionMap.
// It is up to the client to ensure that write operations to p.extensionMap are
// mutually exclusive with other accesses.
p *struct {
mu sync.Mutex
extensionMap map[int32]Extension
// HasExtension reports whether the extension field is present in m
// either as an explicitly populated field or as an unknown field.
func HasExtension(m Message, xt *ExtensionDesc) (has bool) {
mr := MessageReflect(m)
if mr == nil || !mr.IsValid() {
return false
}
}
// extensionsWrite returns the extension map, creating it on first use.
func (e *XXX_InternalExtensions) extensionsWrite() map[int32]Extension {
if e.p == nil {
e.p = new(struct {
mu sync.Mutex
extensionMap map[int32]Extension
// Check whether any populated known field matches the field number.
xtd := xt.TypeDescriptor()
if isValidExtension(mr.Descriptor(), xtd) {
has = mr.Has(xtd)
} else {
mr.Range(func(fd protoreflect.FieldDescriptor, _ protoreflect.Value) bool {
has = int32(fd.Number()) == xt.Field
return !has
})
e.p.extensionMap = make(map[int32]Extension)
}
return e.p.extensionMap
}
// extensionsRead returns the extensions map for read-only use. It may be nil.
// The caller must hold the returned mutex's lock when accessing Elements within the map.
func (e *XXX_InternalExtensions) extensionsRead() (map[int32]Extension, sync.Locker) {
if e.p == nil {
return nil, nil
// Check whether any unknown field matches the field number.
for b := mr.GetUnknown(); !has && len(b) > 0; {
num, _, n := protowire.ConsumeField(b)
has = int32(num) == xt.Field
b = b[n:]
}
return e.p.extensionMap, &e.p.mu
return has
}
// ExtensionDesc represents an extension specification.
// Used in generated code from the protocol compiler.
type ExtensionDesc struct {
ExtendedType Message // nil pointer to the type that is being extended
ExtensionType interface{} // nil pointer to the extension type
Field int32 // field number
Name string // fully-qualified name of extension, for text formatting
Tag string // protobuf tag style
Filename string // name of the file in which the extension is defined
}
func (ed *ExtensionDesc) repeated() bool {
t := reflect.TypeOf(ed.ExtensionType)
return t.Kind() == reflect.Slice && t.Elem().Kind() != reflect.Uint8
}
// Extension represents an extension in a message.
type Extension struct {
// When an extension is stored in a message using SetExtension
// only desc and value are set. When the message is marshaled
// enc will be set to the encoded form of the message.
//
// When a message is unmarshaled and contains extensions, each
// extension will have only enc set. When such an extension is
// accessed using GetExtension (or GetExtensions) desc and value
// will be set.
desc *ExtensionDesc
// value is a concrete value for the extension field. Let the type of
// desc.ExtensionType be the "API type" and the type of Extension.value
// be the "storage type". The API type and storage type are the same except:
// * For scalars (except []byte), the API type uses *T,
// while the storage type uses T.
// * For repeated fields, the API type uses []T, while the storage type
// uses *[]T.
//
// The reason for the divergence is so that the storage type more naturally
// matches what is expected of when retrieving the values through the
// protobuf reflection APIs.
//
// The value may only be populated if desc is also populated.
value interface{}
// enc is the raw bytes for the extension field.
enc []byte
}
// SetRawExtension is for testing only.
func SetRawExtension(base Message, id int32, b []byte) {
epb, err := extendable(base)
if err != nil {
// ClearExtension removes the extension field from m
// either as an explicitly populated field or as an unknown field.
func ClearExtension(m Message, xt *ExtensionDesc) {
mr := MessageReflect(m)
if mr == nil || !mr.IsValid() {
return
}
extmap := epb.extensionsWrite()
extmap[id] = Extension{enc: b}
}
// isExtensionField returns true iff the given field number is in an extension range.
func isExtensionField(pb extendableProto, field int32) bool {
for _, er := range pb.ExtensionRangeArray() {
if er.Start <= field && field <= er.End {
xtd := xt.TypeDescriptor()
if isValidExtension(mr.Descriptor(), xtd) {
mr.Clear(xtd)
} else {
mr.Range(func(fd protoreflect.FieldDescriptor, _ protoreflect.Value) bool {
if int32(fd.Number()) == xt.Field {
mr.Clear(fd)
return false
}
return true
}
})
}
return false
clearUnknown(mr, fieldNum(xt.Field))
}
// checkExtensionTypes checks that the given extension is valid for pb.
func checkExtensionTypes(pb extendableProto, extension *ExtensionDesc) error {
var pbi interface{} = pb
// Check the extended type.
if ea, ok := pbi.(extensionAdapter); ok {
pbi = ea.extendableProtoV1
}
if a, b := reflect.TypeOf(pbi), reflect.TypeOf(extension.ExtendedType); a != b {
return fmt.Errorf("proto: bad extended type; %v does not extend %v", b, a)
}
// Check the range.
if !isExtensionField(pb, extension.Field) {
return errors.New("proto: bad extension number; not in declared ranges")
}
return nil
}
// extPropKey is sufficient to uniquely identify an extension.
type extPropKey struct {
base reflect.Type
field int32
}
var extProp = struct {
sync.RWMutex
m map[extPropKey]*Properties
}{
m: make(map[extPropKey]*Properties),
}
func extensionProperties(ed *ExtensionDesc) *Properties {
key := extPropKey{base: reflect.TypeOf(ed.ExtendedType), field: ed.Field}
extProp.RLock()
if prop, ok := extProp.m[key]; ok {
extProp.RUnlock()
return prop
}
extProp.RUnlock()
extProp.Lock()
defer extProp.Unlock()
// Check again.
if prop, ok := extProp.m[key]; ok {
return prop
}
prop := new(Properties)
prop.Init(reflect.TypeOf(ed.ExtensionType), "unknown_name", ed.Tag, nil)
extProp.m[key] = prop
return prop
}
// HasExtension returns whether the given extension is present in pb.
func HasExtension(pb Message, extension *ExtensionDesc) bool {
// TODO: Check types, field numbers, etc.?
epb, err := extendable(pb)
if err != nil {
return false
}
extmap, mu := epb.extensionsRead()
if extmap == nil {
return false
}
mu.Lock()
_, ok := extmap[extension.Field]
mu.Unlock()
return ok
}
// ClearExtension removes the given extension from pb.
func ClearExtension(pb Message, extension *ExtensionDesc) {
epb, err := extendable(pb)
if err != nil {
// ClearAllExtensions clears all extensions from m.
// This includes populated fields and unknown fields in the extension range.
func ClearAllExtensions(m Message) {
mr := MessageReflect(m)
if mr == nil || !mr.IsValid() {
return
}
// TODO: Check types, field numbers, etc.?
extmap := epb.extensionsWrite()
delete(extmap, extension.Field)
mr.Range(func(fd protoreflect.FieldDescriptor, _ protoreflect.Value) bool {
if fd.IsExtension() {
mr.Clear(fd)
}
return true
})
clearUnknown(mr, mr.Descriptor().ExtensionRanges())
}
// GetExtension retrieves a proto2 extended field from pb.
// GetExtension retrieves a proto2 extended field from m.
//
// If the descriptor is type complete (i.e., ExtensionDesc.ExtensionType is non-nil),
// then GetExtension parses the encoded field and returns a Go value of the specified type.
// If the field is not present, then the default value is returned (if one is specified),
// otherwise ErrMissingExtension is reported.
//
// If the descriptor is not type complete (i.e., ExtensionDesc.ExtensionType is nil),
// then GetExtension returns the raw encoded bytes of the field extension.
func GetExtension(pb Message, extension *ExtensionDesc) (interface{}, error) {
epb, err := extendable(pb)
if err != nil {
return nil, err
// If the descriptor is type incomplete (i.e., ExtensionDesc.ExtensionType is nil),
// then GetExtension returns the raw encoded bytes for the extension field.
func GetExtension(m Message, xt *ExtensionDesc) (interface{}, error) {
mr := MessageReflect(m)
if mr == nil || !mr.IsValid() || mr.Descriptor().ExtensionRanges().Len() == 0 {
return nil, errNotExtendable
}
if extension.ExtendedType != nil {
// can only check type if this is a complete descriptor
if err := checkExtensionTypes(epb, extension); err != nil {
// Retrieve the unknown fields for this extension field.
var bo protoreflect.RawFields
for bi := mr.GetUnknown(); len(bi) > 0; {
num, _, n := protowire.ConsumeField(bi)
if int32(num) == xt.Field {
bo = append(bo, bi[:n]...)
}
bi = bi[n:]
}
// For type incomplete descriptors, only retrieve the unknown fields.
if xt.ExtensionType == nil {
return []byte(bo), nil
}
// If the extension field only exists as unknown fields, unmarshal it.
// This is rarely done since proto.Unmarshal eagerly unmarshals extensions.
xtd := xt.TypeDescriptor()
if !isValidExtension(mr.Descriptor(), xtd) {
return nil, fmt.Errorf("proto: bad extended type; %T does not extend %T", xt.ExtendedType, m)
}
if !mr.Has(xtd) && len(bo) > 0 {
m2 := mr.New()
if err := (proto.UnmarshalOptions{
Resolver: extensionResolver{xt},
}.Unmarshal(bo, m2.Interface())); err != nil {
return nil, err
}
}
emap, mu := epb.extensionsRead()
if emap == nil {
return defaultExtensionValue(extension)
}
mu.Lock()
defer mu.Unlock()
e, ok := emap[extension.Field]
if !ok {
// defaultExtensionValue returns the default value or
// ErrMissingExtension if there is no default.
return defaultExtensionValue(extension)
}
if e.value != nil {
// Already decoded. Check the descriptor, though.
if e.desc != extension {
// This shouldn't happen. If it does, it means that
// GetExtension was called twice with two different
// descriptors with the same field number.
return nil, errors.New("proto: descriptor conflict")
if m2.Has(xtd) {
mr.Set(xtd, m2.Get(xtd))
clearUnknown(mr, fieldNum(xt.Field))
}
return extensionAsLegacyType(e.value), nil
}
if extension.ExtensionType == nil {
// incomplete descriptor
return e.enc, nil
}
v, err := decodeExtension(e.enc, extension)
if err != nil {
return nil, err
}
// Remember the decoded version and drop the encoded version.
// That way it is safe to mutate what we return.
e.value = extensionAsStorageType(v)
e.desc = extension
e.enc = nil
emap[extension.Field] = e
return extensionAsLegacyType(e.value), nil
}
// defaultExtensionValue returns the default value for extension.
// If no default for an extension is defined ErrMissingExtension is returned.
func defaultExtensionValue(extension *ExtensionDesc) (interface{}, error) {
if extension.ExtensionType == nil {
// incomplete descriptor, so no default
// Check whether the message has the extension field set or a default.
var pv protoreflect.Value
switch {
case mr.Has(xtd):
pv = mr.Get(xtd)
case xtd.HasDefault():
pv = xtd.Default()
default:
return nil, ErrMissingExtension
}
t := reflect.TypeOf(extension.ExtensionType)
props := extensionProperties(extension)
sf, _, err := fieldDefault(t, props)
if err != nil {
return nil, err
}
if sf == nil || sf.value == nil {
// There is no default value.
return nil, ErrMissingExtension
}
if t.Kind() != reflect.Ptr {
// We do not need to return a Ptr, we can directly return sf.value.
return sf.value, nil
}
// We need to return an interface{} that is a pointer to sf.value.
value := reflect.New(t).Elem()
value.Set(reflect.New(value.Type().Elem()))
if sf.kind == reflect.Int32 {
// We may have an int32 or an enum, but the underlying data is int32.
// Since we can't set an int32 into a non int32 reflect.value directly
// set it as a int32.
value.Elem().SetInt(int64(sf.value.(int32)))
} else {
value.Elem().Set(reflect.ValueOf(sf.value))
}
return value.Interface(), nil
}
// decodeExtension decodes an extension encoded in b.
func decodeExtension(b []byte, extension *ExtensionDesc) (interface{}, error) {
t := reflect.TypeOf(extension.ExtensionType)
unmarshal := typeUnmarshaler(t, extension.Tag)
// t is a pointer to a struct, pointer to basic type or a slice.
// Allocate space to store the pointer/slice.
value := reflect.New(t).Elem()
var err error
for {
x, n := decodeVarint(b)
if n == 0 {
return nil, io.ErrUnexpectedEOF
}
b = b[n:]
wire := int(x) & 7
b, err = unmarshal(b, valToPointer(value.Addr()), wire)
if err != nil {
return nil, err
}
if len(b) == 0 {
break
}
}
return value.Interface(), nil
}
// GetExtensions returns a slice of the extensions present in pb that are also listed in es.
// The returned slice has the same length as es; missing extensions will appear as nil elements.
func GetExtensions(pb Message, es []*ExtensionDesc) (extensions []interface{}, err error) {
epb, err := extendable(pb)
if err != nil {
return nil, err
}
extensions = make([]interface{}, len(es))
for i, e := range es {
extensions[i], err = GetExtension(epb, e)
if err == ErrMissingExtension {
err = nil
}
if err != nil {
return
}
}
return
}
// ExtensionDescs returns a new slice containing pb's extension descriptors, in undefined order.
// For non-registered extensions, ExtensionDescs returns an incomplete descriptor containing
// just the Field field, which defines the extension's field number.
func ExtensionDescs(pb Message) ([]*ExtensionDesc, error) {
epb, err := extendable(pb)
if err != nil {
return nil, err
}
registeredExtensions := RegisteredExtensions(pb)
emap, mu := epb.extensionsRead()
if emap == nil {
return nil, nil
}
mu.Lock()
defer mu.Unlock()
extensions := make([]*ExtensionDesc, 0, len(emap))
for extid, e := range emap {
desc := e.desc
if desc == nil {
desc = registeredExtensions[extid]
if desc == nil {
desc = &ExtensionDesc{Field: extid}
}
}
extensions = append(extensions, desc)
}
return extensions, nil
}
// SetExtension sets the specified extension of pb to the specified value.
func SetExtension(pb Message, extension *ExtensionDesc, value interface{}) error {
epb, err := extendable(pb)
if err != nil {
return err
}
if err := checkExtensionTypes(epb, extension); err != nil {
return err
}
typ := reflect.TypeOf(extension.ExtensionType)
if typ != reflect.TypeOf(value) {
return fmt.Errorf("proto: bad extension value type. got: %T, want: %T", value, extension.ExtensionType)
}
// nil extension values need to be caught early, because the
// encoder can't distinguish an ErrNil due to a nil extension
// from an ErrNil due to a missing field. Extensions are
// always optional, so the encoder would just swallow the error
// and drop all the extensions from the encoded message.
if reflect.ValueOf(value).IsNil() {
return fmt.Errorf("proto: SetExtension called with nil value of type %T", value)
}
extmap := epb.extensionsWrite()
extmap[extension.Field] = Extension{desc: extension, value: extensionAsStorageType(value)}
return nil
}
// ClearAllExtensions clears all extensions from pb.
func ClearAllExtensions(pb Message) {
epb, err := extendable(pb)
if err != nil {
return
}
m := epb.extensionsWrite()
for k := range m {
delete(m, k)
}
}
// A global registry of extensions.
// The generated code will register the generated descriptors by calling RegisterExtension.
var extensionMaps = make(map[reflect.Type]map[int32]*ExtensionDesc)
// RegisterExtension is called from the generated code.
func RegisterExtension(desc *ExtensionDesc) {
st := reflect.TypeOf(desc.ExtendedType).Elem()
m := extensionMaps[st]
if m == nil {
m = make(map[int32]*ExtensionDesc)
extensionMaps[st] = m
}
if _, ok := m[desc.Field]; ok {
panic("proto: duplicate extension registered: " + st.String() + " " + strconv.Itoa(int(desc.Field)))
}
m[desc.Field] = desc
}
// RegisteredExtensions returns a map of the registered extensions of a
// protocol buffer struct, indexed by the extension number.
// The argument pb should be a nil pointer to the struct type.
func RegisteredExtensions(pb Message) map[int32]*ExtensionDesc {
return extensionMaps[reflect.TypeOf(pb).Elem()]
}
// extensionAsLegacyType converts an value in the storage type as the API type.
// See Extension.value.
func extensionAsLegacyType(v interface{}) interface{} {
switch rv := reflect.ValueOf(v); rv.Kind() {
case reflect.Bool, reflect.Int32, reflect.Int64, reflect.Uint32, reflect.Uint64, reflect.Float32, reflect.Float64, reflect.String:
// Represent primitive types as a pointer to the value.
v := xt.InterfaceOf(pv)
rv := reflect.ValueOf(v)
if isScalarKind(rv.Kind()) {
rv2 := reflect.New(rv.Type())
rv2.Elem().Set(rv)
v = rv2.Interface()
case reflect.Ptr:
// Represent slice types as the value itself.
switch rv.Type().Elem().Kind() {
case reflect.Slice:
if rv.IsNil() {
v = reflect.Zero(rv.Type().Elem()).Interface()
} else {
v = rv.Elem().Interface()
}
}
}
return v
return v, nil
}
// extensionAsStorageType converts an value in the API type as the storage type.
// See Extension.value.
func extensionAsStorageType(v interface{}) interface{} {
switch rv := reflect.ValueOf(v); rv.Kind() {
case reflect.Ptr:
// Represent slice types as the value itself.
switch rv.Type().Elem().Kind() {
case reflect.Bool, reflect.Int32, reflect.Int64, reflect.Uint32, reflect.Uint64, reflect.Float32, reflect.Float64, reflect.String:
if rv.IsNil() {
v = reflect.Zero(rv.Type().Elem()).Interface()
} else {
v = rv.Elem().Interface()
// extensionResolver is a custom extension resolver that stores a single
// extension type that takes precedence over the global registry.
type extensionResolver struct{ xt protoreflect.ExtensionType }
func (r extensionResolver) FindExtensionByName(field protoreflect.FullName) (protoreflect.ExtensionType, error) {
if xtd := r.xt.TypeDescriptor(); xtd.FullName() == field {
return r.xt, nil
}
return protoregistry.GlobalTypes.FindExtensionByName(field)
}
func (r extensionResolver) FindExtensionByNumber(message protoreflect.FullName, field protoreflect.FieldNumber) (protoreflect.ExtensionType, error) {
if xtd := r.xt.TypeDescriptor(); xtd.ContainingMessage().FullName() == message && xtd.Number() == field {
return r.xt, nil
}
return protoregistry.GlobalTypes.FindExtensionByNumber(message, field)
}
// GetExtensions returns a list of the extensions values present in m,
// corresponding with the provided list of extension descriptors, xts.
// If an extension is missing in m, the corresponding value is nil.
func GetExtensions(m Message, xts []*ExtensionDesc) ([]interface{}, error) {
mr := MessageReflect(m)
if mr == nil || !mr.IsValid() {
return nil, errNotExtendable
}
vs := make([]interface{}, len(xts))
for i, xt := range xts {
v, err := GetExtension(m, xt)
if err != nil {
if err == ErrMissingExtension {
continue
}
return vs, err
}
case reflect.Slice:
// Represent slice types as a pointer to the value.
if rv.Type().Elem().Kind() != reflect.Uint8 {
rv2 := reflect.New(rv.Type())
rv2.Elem().Set(rv)
v = rv2.Interface()
vs[i] = v
}
return vs, nil
}
// SetExtension sets an extension field in m to the provided value.
func SetExtension(m Message, xt *ExtensionDesc, v interface{}) error {
mr := MessageReflect(m)
if mr == nil || !mr.IsValid() || mr.Descriptor().ExtensionRanges().Len() == 0 {
return errNotExtendable
}
rv := reflect.ValueOf(v)
if reflect.TypeOf(v) != reflect.TypeOf(xt.ExtensionType) {
return fmt.Errorf("proto: bad extension value type. got: %T, want: %T", v, xt.ExtensionType)
}
if rv.Kind() == reflect.Ptr {
if rv.IsNil() {
return fmt.Errorf("proto: SetExtension called with nil value of type %T", v)
}
if isScalarKind(rv.Elem().Kind()) {
v = rv.Elem().Interface()
}
}
return v
xtd := xt.TypeDescriptor()
if !isValidExtension(mr.Descriptor(), xtd) {
return fmt.Errorf("proto: bad extended type; %T does not extend %T", xt.ExtendedType, m)
}
mr.Set(xtd, xt.ValueOf(v))
clearUnknown(mr, fieldNum(xt.Field))
return nil
}
// SetRawExtension inserts b into the unknown fields of m.
//
// Deprecated: Use Message.ProtoReflect.SetUnknown instead.
func SetRawExtension(m Message, fnum int32, b []byte) {
mr := MessageReflect(m)
if mr == nil || !mr.IsValid() {
return
}
// Verify that the raw field is valid.
for b0 := b; len(b0) > 0; {
num, _, n := protowire.ConsumeField(b0)
if int32(num) != fnum {
panic(fmt.Sprintf("mismatching field number: got %d, want %d", num, fnum))
}
b0 = b0[n:]
}
ClearExtension(m, &ExtensionDesc{Field: fnum})
mr.SetUnknown(append(mr.GetUnknown(), b...))
}
// ExtensionDescs returns a list of extension descriptors found in m,
// containing descriptors for both populated extension fields in m and
// also unknown fields of m that are in the extension range.
// For the later case, an type incomplete descriptor is provided where only
// the ExtensionDesc.Field field is populated.
// The order of the extension descriptors is undefined.
func ExtensionDescs(m Message) ([]*ExtensionDesc, error) {
mr := MessageReflect(m)
if mr == nil || !mr.IsValid() || mr.Descriptor().ExtensionRanges().Len() == 0 {
return nil, errNotExtendable
}
// Collect a set of known extension descriptors.
extDescs := make(map[protoreflect.FieldNumber]*ExtensionDesc)
mr.Range(func(fd protoreflect.FieldDescriptor, v protoreflect.Value) bool {
if fd.IsExtension() {
xt := fd.(protoreflect.ExtensionTypeDescriptor)
if xd, ok := xt.Type().(*ExtensionDesc); ok {
extDescs[fd.Number()] = xd
}
}
return true
})
// Collect a set of unknown extension descriptors.
extRanges := mr.Descriptor().ExtensionRanges()
for b := mr.GetUnknown(); len(b) > 0; {
num, _, n := protowire.ConsumeField(b)
if extRanges.Has(num) && extDescs[num] == nil {
extDescs[num] = nil
}
b = b[n:]
}
// Transpose the set of descriptors into a list.
var xts []*ExtensionDesc
for num, xt := range extDescs {
if xt == nil {
xt = &ExtensionDesc{Field: int32(num)}
}
xts = append(xts, xt)
}
return xts, nil
}
// isValidExtension reports whether xtd is a valid extension descriptor for md.
func isValidExtension(md protoreflect.MessageDescriptor, xtd protoreflect.ExtensionTypeDescriptor) bool {
return xtd.ContainingMessage() == md && md.ExtensionRanges().Has(xtd.Number())
}
// isScalarKind reports whether k is a protobuf scalar kind (except bytes).
// This function exists for historical reasons since the representation of
// scalars differs between v1 and v2, where v1 uses *T and v2 uses T.
func isScalarKind(k reflect.Kind) bool {
switch k {
case reflect.Bool, reflect.Int32, reflect.Int64, reflect.Uint32, reflect.Uint64, reflect.Float32, reflect.Float64, reflect.String:
return true
default:
return false
}
}
// clearUnknown removes unknown fields from m where remover.Has reports true.
func clearUnknown(m protoreflect.Message, remover interface {
Has(protoreflect.FieldNumber) bool
}) {
var bo protoreflect.RawFields
for bi := m.GetUnknown(); len(bi) > 0; {
num, _, n := protowire.ConsumeField(bi)
if !remover.Has(num) {
bo = append(bo, bi[:n]...)
}
bi = bi[n:]
}
if bi := m.GetUnknown(); len(bi) != len(bo) {
m.SetUnknown(bo)
}
}
type fieldNum protoreflect.FieldNumber
func (n1 fieldNum) Has(n2 protoreflect.FieldNumber) bool {
return protoreflect.FieldNumber(n1) == n2
}

965
vendor/github.com/golang/protobuf/proto/lib.go generated vendored
View file

@ -1,965 +0,0 @@
// Go support for Protocol Buffers - Google's data interchange format
//
// Copyright 2010 The Go Authors. All rights reserved.
// https://github.com/golang/protobuf
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
// * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
// * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following disclaimer
// in the documentation and/or other materials provided with the
// distribution.
// * Neither the name of Google Inc. nor the names of its
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
/*
Package proto converts data structures to and from the wire format of
protocol buffers. It works in concert with the Go source code generated
for .proto files by the protocol compiler.
A summary of the properties of the protocol buffer interface
for a protocol buffer variable v:
- Names are turned from camel_case to CamelCase for export.
- There are no methods on v to set fields; just treat
them as structure fields.
- There are getters that return a field's value if set,
and return the field's default value if unset.
The getters work even if the receiver is a nil message.
- The zero value for a struct is its correct initialization state.
All desired fields must be set before marshaling.
- A Reset() method will restore a protobuf struct to its zero state.
- Non-repeated fields are pointers to the values; nil means unset.
That is, optional or required field int32 f becomes F *int32.
- Repeated fields are slices.
- Helper functions are available to aid the setting of fields.
msg.Foo = proto.String("hello") // set field
- Constants are defined to hold the default values of all fields that
have them. They have the form Default_StructName_FieldName.
Because the getter methods handle defaulted values,
direct use of these constants should be rare.
- Enums are given type names and maps from names to values.
Enum values are prefixed by the enclosing message's name, or by the
enum's type name if it is a top-level enum. Enum types have a String
method, and a Enum method to assist in message construction.
- Nested messages, groups and enums have type names prefixed with the name of
the surrounding message type.
- Extensions are given descriptor names that start with E_,
followed by an underscore-delimited list of the nested messages
that contain it (if any) followed by the CamelCased name of the
extension field itself. HasExtension, ClearExtension, GetExtension
and SetExtension are functions for manipulating extensions.
- Oneof field sets are given a single field in their message,
with distinguished wrapper types for each possible field value.
- Marshal and Unmarshal are functions to encode and decode the wire format.
When the .proto file specifies `syntax="proto3"`, there are some differences:
- Non-repeated fields of non-message type are values instead of pointers.
- Enum types do not get an Enum method.
The simplest way to describe this is to see an example.
Given file test.proto, containing
package example;
enum FOO { X = 17; }
message Test {
required string label = 1;
optional int32 type = 2 [default=77];
repeated int64 reps = 3;
optional group OptionalGroup = 4 {
required string RequiredField = 5;
}
oneof union {
int32 number = 6;
string name = 7;
}
}
The resulting file, test.pb.go, is:
package example
import proto "github.com/golang/protobuf/proto"
import math "math"
type FOO int32
const (
FOO_X FOO = 17
)
var FOO_name = map[int32]string{
17: "X",
}
var FOO_value = map[string]int32{
"X": 17,
}
func (x FOO) Enum() *FOO {
p := new(FOO)
*p = x
return p
}
func (x FOO) String() string {
return proto.EnumName(FOO_name, int32(x))
}
func (x *FOO) UnmarshalJSON(data []byte) error {
value, err := proto.UnmarshalJSONEnum(FOO_value, data)
if err != nil {
return err
}
*x = FOO(value)
return nil
}
type Test struct {
Label *string `protobuf:"bytes,1,req,name=label" json:"label,omitempty"`
Type *int32 `protobuf:"varint,2,opt,name=type,def=77" json:"type,omitempty"`
Reps []int64 `protobuf:"varint,3,rep,name=reps" json:"reps,omitempty"`
Optionalgroup *Test_OptionalGroup `protobuf:"group,4,opt,name=OptionalGroup" json:"optionalgroup,omitempty"`
// Types that are valid to be assigned to Union:
// *Test_Number
// *Test_Name
Union isTest_Union `protobuf_oneof:"union"`
XXX_unrecognized []byte `json:"-"`
}
func (m *Test) Reset() { *m = Test{} }
func (m *Test) String() string { return proto.CompactTextString(m) }
func (*Test) ProtoMessage() {}
type isTest_Union interface {
isTest_Union()
}
type Test_Number struct {
Number int32 `protobuf:"varint,6,opt,name=number"`
}
type Test_Name struct {
Name string `protobuf:"bytes,7,opt,name=name"`
}
func (*Test_Number) isTest_Union() {}
func (*Test_Name) isTest_Union() {}
func (m *Test) GetUnion() isTest_Union {
if m != nil {
return m.Union
}
return nil
}
const Default_Test_Type int32 = 77
func (m *Test) GetLabel() string {
if m != nil && m.Label != nil {
return *m.Label
}
return ""
}
func (m *Test) GetType() int32 {
if m != nil && m.Type != nil {
return *m.Type
}
return Default_Test_Type
}
func (m *Test) GetOptionalgroup() *Test_OptionalGroup {
if m != nil {
return m.Optionalgroup
}
return nil
}
type Test_OptionalGroup struct {
RequiredField *string `protobuf:"bytes,5,req" json:"RequiredField,omitempty"`
}
func (m *Test_OptionalGroup) Reset() { *m = Test_OptionalGroup{} }
func (m *Test_OptionalGroup) String() string { return proto.CompactTextString(m) }
func (m *Test_OptionalGroup) GetRequiredField() string {
if m != nil && m.RequiredField != nil {
return *m.RequiredField
}
return ""
}
func (m *Test) GetNumber() int32 {
if x, ok := m.GetUnion().(*Test_Number); ok {
return x.Number
}
return 0
}
func (m *Test) GetName() string {
if x, ok := m.GetUnion().(*Test_Name); ok {
return x.Name
}
return ""
}
func init() {
proto.RegisterEnum("example.FOO", FOO_name, FOO_value)
}
To create and play with a Test object:
package main
import (
"log"
"github.com/golang/protobuf/proto"
pb "./example.pb"
)
func main() {
test := &pb.Test{
Label: proto.String("hello"),
Type: proto.Int32(17),
Reps: []int64{1, 2, 3},
Optionalgroup: &pb.Test_OptionalGroup{
RequiredField: proto.String("good bye"),
},
Union: &pb.Test_Name{"fred"},
}
data, err := proto.Marshal(test)
if err != nil {
log.Fatal("marshaling error: ", err)
}
newTest := &pb.Test{}
err = proto.Unmarshal(data, newTest)
if err != nil {
log.Fatal("unmarshaling error: ", err)
}
// Now test and newTest contain the same data.
if test.GetLabel() != newTest.GetLabel() {
log.Fatalf("data mismatch %q != %q", test.GetLabel(), newTest.GetLabel())
}
// Use a type switch to determine which oneof was set.
switch u := test.Union.(type) {
case *pb.Test_Number: // u.Number contains the number.
case *pb.Test_Name: // u.Name contains the string.
}
// etc.
}
*/
package proto
import (
"encoding/json"
"fmt"
"log"
"reflect"
"sort"
"strconv"
"sync"
)
// RequiredNotSetError is an error type returned by either Marshal or Unmarshal.
// Marshal reports this when a required field is not initialized.
// Unmarshal reports this when a required field is missing from the wire data.
type RequiredNotSetError struct{ field string }
func (e *RequiredNotSetError) Error() string {
if e.field == "" {
return fmt.Sprintf("proto: required field not set")
}
return fmt.Sprintf("proto: required field %q not set", e.field)
}
func (e *RequiredNotSetError) RequiredNotSet() bool {
return true
}
type invalidUTF8Error struct{ field string }
func (e *invalidUTF8Error) Error() string {
if e.field == "" {
return "proto: invalid UTF-8 detected"
}
return fmt.Sprintf("proto: field %q contains invalid UTF-8", e.field)
}
func (e *invalidUTF8Error) InvalidUTF8() bool {
return true
}
// errInvalidUTF8 is a sentinel error to identify fields with invalid UTF-8.
// This error should not be exposed to the external API as such errors should
// be recreated with the field information.
var errInvalidUTF8 = &invalidUTF8Error{}
// isNonFatal reports whether the error is either a RequiredNotSet error
// or a InvalidUTF8 error.
func isNonFatal(err error) bool {
if re, ok := err.(interface{ RequiredNotSet() bool }); ok && re.RequiredNotSet() {
return true
}
if re, ok := err.(interface{ InvalidUTF8() bool }); ok && re.InvalidUTF8() {
return true
}
return false
}
type nonFatal struct{ E error }
// Merge merges err into nf and reports whether it was successful.
// Otherwise it returns false for any fatal non-nil errors.
func (nf *nonFatal) Merge(err error) (ok bool) {
if err == nil {
return true // not an error
}
if !isNonFatal(err) {
return false // fatal error
}
if nf.E == nil {
nf.E = err // store first instance of non-fatal error
}
return true
}
// Message is implemented by generated protocol buffer messages.
type Message interface {
Reset()
String() string
ProtoMessage()
}
// A Buffer is a buffer manager for marshaling and unmarshaling
// protocol buffers. It may be reused between invocations to
// reduce memory usage. It is not necessary to use a Buffer;
// the global functions Marshal and Unmarshal create a
// temporary Buffer and are fine for most applications.
type Buffer struct {
buf []byte // encode/decode byte stream
index int // read point
deterministic bool
}
// NewBuffer allocates a new Buffer and initializes its internal data to
// the contents of the argument slice.
func NewBuffer(e []byte) *Buffer {
return &Buffer{buf: e}
}
// Reset resets the Buffer, ready for marshaling a new protocol buffer.
func (p *Buffer) Reset() {
p.buf = p.buf[0:0] // for reading/writing
p.index = 0 // for reading
}
// SetBuf replaces the internal buffer with the slice,
// ready for unmarshaling the contents of the slice.
func (p *Buffer) SetBuf(s []byte) {
p.buf = s
p.index = 0
}
// Bytes returns the contents of the Buffer.
func (p *Buffer) Bytes() []byte { return p.buf }
// SetDeterministic sets whether to use deterministic serialization.
//
// Deterministic serialization guarantees that for a given binary, equal
// messages will always be serialized to the same bytes. This implies:
//
// - Repeated serialization of a message will return the same bytes.
// - Different processes of the same binary (which may be executing on
// different machines) will serialize equal messages to the same bytes.
//
// Note that the deterministic serialization is NOT canonical across
// languages. It is not guaranteed to remain stable over time. It is unstable
// across different builds with schema changes due to unknown fields.
// Users who need canonical serialization (e.g., persistent storage in a
// canonical form, fingerprinting, etc.) should define their own
// canonicalization specification and implement their own serializer rather
// than relying on this API.
//
// If deterministic serialization is requested, map entries will be sorted
// by keys in lexicographical order. This is an implementation detail and
// subject to change.
func (p *Buffer) SetDeterministic(deterministic bool) {
p.deterministic = deterministic
}
/*
* Helper routines for simplifying the creation of optional fields of basic type.
*/
// Bool is a helper routine that allocates a new bool value
// to store v and returns a pointer to it.
func Bool(v bool) *bool {
return &v
}
// Int32 is a helper routine that allocates a new int32 value
// to store v and returns a pointer to it.
func Int32(v int32) *int32 {
return &v
}
// Int is a helper routine that allocates a new int32 value
// to store v and returns a pointer to it, but unlike Int32
// its argument value is an int.
func Int(v int) *int32 {
p := new(int32)
*p = int32(v)
return p
}
// Int64 is a helper routine that allocates a new int64 value
// to store v and returns a pointer to it.
func Int64(v int64) *int64 {
return &v
}
// Float32 is a helper routine that allocates a new float32 value
// to store v and returns a pointer to it.
func Float32(v float32) *float32 {
return &v
}
// Float64 is a helper routine that allocates a new float64 value
// to store v and returns a pointer to it.
func Float64(v float64) *float64 {
return &v
}
// Uint32 is a helper routine that allocates a new uint32 value
// to store v and returns a pointer to it.
func Uint32(v uint32) *uint32 {
return &v
}
// Uint64 is a helper routine that allocates a new uint64 value
// to store v and returns a pointer to it.
func Uint64(v uint64) *uint64 {
return &v
}
// String is a helper routine that allocates a new string value
// to store v and returns a pointer to it.
func String(v string) *string {
return &v
}
// EnumName is a helper function to simplify printing protocol buffer enums
// by name. Given an enum map and a value, it returns a useful string.
func EnumName(m map[int32]string, v int32) string {
s, ok := m[v]
if ok {
return s
}
return strconv.Itoa(int(v))
}
// UnmarshalJSONEnum is a helper function to simplify recovering enum int values
// from their JSON-encoded representation. Given a map from the enum's symbolic
// names to its int values, and a byte buffer containing the JSON-encoded
// value, it returns an int32 that can be cast to the enum type by the caller.
//
// The function can deal with both JSON representations, numeric and symbolic.
func UnmarshalJSONEnum(m map[string]int32, data []byte, enumName string) (int32, error) {
if data[0] == '"' {
// New style: enums are strings.
var repr string
if err := json.Unmarshal(data, &repr); err != nil {
return -1, err
}
val, ok := m[repr]
if !ok {
return 0, fmt.Errorf("unrecognized enum %s value %q", enumName, repr)
}
return val, nil
}
// Old style: enums are ints.
var val int32
if err := json.Unmarshal(data, &val); err != nil {
return 0, fmt.Errorf("cannot unmarshal %#q into enum %s", data, enumName)
}
return val, nil
}
// DebugPrint dumps the encoded data in b in a debugging format with a header
// including the string s. Used in testing but made available for general debugging.
func (p *Buffer) DebugPrint(s string, b []byte) {
var u uint64
obuf := p.buf
index := p.index
p.buf = b
p.index = 0
depth := 0
fmt.Printf("\n--- %s ---\n", s)
out:
for {
for i := 0; i < depth; i++ {
fmt.Print(" ")
}
index := p.index
if index == len(p.buf) {
break
}
op, err := p.DecodeVarint()
if err != nil {
fmt.Printf("%3d: fetching op err %v\n", index, err)
break out
}
tag := op >> 3
wire := op & 7
switch wire {
default:
fmt.Printf("%3d: t=%3d unknown wire=%d\n",
index, tag, wire)
break out
case WireBytes:
var r []byte
r, err = p.DecodeRawBytes(false)
if err != nil {
break out
}
fmt.Printf("%3d: t=%3d bytes [%d]", index, tag, len(r))
if len(r) <= 6 {
for i := 0; i < len(r); i++ {
fmt.Printf(" %.2x", r[i])
}
} else {
for i := 0; i < 3; i++ {
fmt.Printf(" %.2x", r[i])
}
fmt.Printf(" ..")
for i := len(r) - 3; i < len(r); i++ {
fmt.Printf(" %.2x", r[i])
}
}
fmt.Printf("\n")
case WireFixed32:
u, err = p.DecodeFixed32()
if err != nil {
fmt.Printf("%3d: t=%3d fix32 err %v\n", index, tag, err)
break out
}
fmt.Printf("%3d: t=%3d fix32 %d\n", index, tag, u)
case WireFixed64:
u, err = p.DecodeFixed64()
if err != nil {
fmt.Printf("%3d: t=%3d fix64 err %v\n", index, tag, err)
break out
}
fmt.Printf("%3d: t=%3d fix64 %d\n", index, tag, u)
case WireVarint:
u, err = p.DecodeVarint()
if err != nil {
fmt.Printf("%3d: t=%3d varint err %v\n", index, tag, err)
break out
}
fmt.Printf("%3d: t=%3d varint %d\n", index, tag, u)
case WireStartGroup:
fmt.Printf("%3d: t=%3d start\n", index, tag)
depth++
case WireEndGroup:
depth--
fmt.Printf("%3d: t=%3d end\n", index, tag)
}
}
if depth != 0 {
fmt.Printf("%3d: start-end not balanced %d\n", p.index, depth)
}
fmt.Printf("\n")
p.buf = obuf
p.index = index
}
// SetDefaults sets unset protocol buffer fields to their default values.
// It only modifies fields that are both unset and have defined defaults.
// It recursively sets default values in any non-nil sub-messages.
func SetDefaults(pb Message) {
setDefaults(reflect.ValueOf(pb), true, false)
}
// v is a pointer to a struct.
func setDefaults(v reflect.Value, recur, zeros bool) {
v = v.Elem()
defaultMu.RLock()
dm, ok := defaults[v.Type()]
defaultMu.RUnlock()
if !ok {
dm = buildDefaultMessage(v.Type())
defaultMu.Lock()
defaults[v.Type()] = dm
defaultMu.Unlock()
}
for _, sf := range dm.scalars {
f := v.Field(sf.index)
if !f.IsNil() {
// field already set
continue
}
dv := sf.value
if dv == nil && !zeros {
// no explicit default, and don't want to set zeros
continue
}
fptr := f.Addr().Interface() // **T
// TODO: Consider batching the allocations we do here.
switch sf.kind {
case reflect.Bool:
b := new(bool)
if dv != nil {
*b = dv.(bool)
}
*(fptr.(**bool)) = b
case reflect.Float32:
f := new(float32)
if dv != nil {
*f = dv.(float32)
}
*(fptr.(**float32)) = f
case reflect.Float64:
f := new(float64)
if dv != nil {
*f = dv.(float64)
}
*(fptr.(**float64)) = f
case reflect.Int32:
// might be an enum
if ft := f.Type(); ft != int32PtrType {
// enum
f.Set(reflect.New(ft.Elem()))
if dv != nil {
f.Elem().SetInt(int64(dv.(int32)))
}
} else {
// int32 field
i := new(int32)
if dv != nil {
*i = dv.(int32)
}
*(fptr.(**int32)) = i
}
case reflect.Int64:
i := new(int64)
if dv != nil {
*i = dv.(int64)
}
*(fptr.(**int64)) = i
case reflect.String:
s := new(string)
if dv != nil {
*s = dv.(string)
}
*(fptr.(**string)) = s
case reflect.Uint8:
// exceptional case: []byte
var b []byte
if dv != nil {
db := dv.([]byte)
b = make([]byte, len(db))
copy(b, db)
} else {
b = []byte{}
}
*(fptr.(*[]byte)) = b
case reflect.Uint32:
u := new(uint32)
if dv != nil {
*u = dv.(uint32)
}
*(fptr.(**uint32)) = u
case reflect.Uint64:
u := new(uint64)
if dv != nil {
*u = dv.(uint64)
}
*(fptr.(**uint64)) = u
default:
log.Printf("proto: can't set default for field %v (sf.kind=%v)", f, sf.kind)
}
}
for _, ni := range dm.nested {
f := v.Field(ni)
// f is *T or []*T or map[T]*T
switch f.Kind() {
case reflect.Ptr:
if f.IsNil() {
continue
}
setDefaults(f, recur, zeros)
case reflect.Slice:
for i := 0; i < f.Len(); i++ {
e := f.Index(i)
if e.IsNil() {
continue
}
setDefaults(e, recur, zeros)
}
case reflect.Map:
for _, k := range f.MapKeys() {
e := f.MapIndex(k)
if e.IsNil() {
continue
}
setDefaults(e, recur, zeros)
}
}
}
}
var (
// defaults maps a protocol buffer struct type to a slice of the fields,
// with its scalar fields set to their proto-declared non-zero default values.
defaultMu sync.RWMutex
defaults = make(map[reflect.Type]defaultMessage)
int32PtrType = reflect.TypeOf((*int32)(nil))
)
// defaultMessage represents information about the default values of a message.
type defaultMessage struct {
scalars []scalarField
nested []int // struct field index of nested messages
}
type scalarField struct {
index int // struct field index
kind reflect.Kind // element type (the T in *T or []T)
value interface{} // the proto-declared default value, or nil
}
// t is a struct type.
func buildDefaultMessage(t reflect.Type) (dm defaultMessage) {
sprop := GetProperties(t)
for _, prop := range sprop.Prop {
fi, ok := sprop.decoderTags.get(prop.Tag)
if !ok {
// XXX_unrecognized
continue
}
ft := t.Field(fi).Type
sf, nested, err := fieldDefault(ft, prop)
switch {
case err != nil:
log.Print(err)
case nested:
dm.nested = append(dm.nested, fi)
case sf != nil:
sf.index = fi
dm.scalars = append(dm.scalars, *sf)
}
}
return dm
}
// fieldDefault returns the scalarField for field type ft.
// sf will be nil if the field can not have a default.
// nestedMessage will be true if this is a nested message.
// Note that sf.index is not set on return.
func fieldDefault(ft reflect.Type, prop *Properties) (sf *scalarField, nestedMessage bool, err error) {
var canHaveDefault bool
switch ft.Kind() {
case reflect.Ptr:
if ft.Elem().Kind() == reflect.Struct {
nestedMessage = true
} else {
canHaveDefault = true // proto2 scalar field
}
case reflect.Slice:
switch ft.Elem().Kind() {
case reflect.Ptr:
nestedMessage = true // repeated message
case reflect.Uint8:
canHaveDefault = true // bytes field
}
case reflect.Map:
if ft.Elem().Kind() == reflect.Ptr {
nestedMessage = true // map with message values
}
}
if !canHaveDefault {
if nestedMessage {
return nil, true, nil
}
return nil, false, nil
}
// We now know that ft is a pointer or slice.
sf = &scalarField{kind: ft.Elem().Kind()}
// scalar fields without defaults
if !prop.HasDefault {
return sf, false, nil
}
// a scalar field: either *T or []byte
switch ft.Elem().Kind() {
case reflect.Bool:
x, err := strconv.ParseBool(prop.Default)
if err != nil {
return nil, false, fmt.Errorf("proto: bad default bool %q: %v", prop.Default, err)
}
sf.value = x
case reflect.Float32:
x, err := strconv.ParseFloat(prop.Default, 32)
if err != nil {
return nil, false, fmt.Errorf("proto: bad default float32 %q: %v", prop.Default, err)
}
sf.value = float32(x)
case reflect.Float64:
x, err := strconv.ParseFloat(prop.Default, 64)
if err != nil {
return nil, false, fmt.Errorf("proto: bad default float64 %q: %v", prop.Default, err)
}
sf.value = x
case reflect.Int32:
x, err := strconv.ParseInt(prop.Default, 10, 32)
if err != nil {
return nil, false, fmt.Errorf("proto: bad default int32 %q: %v", prop.Default, err)
}
sf.value = int32(x)
case reflect.Int64:
x, err := strconv.ParseInt(prop.Default, 10, 64)
if err != nil {
return nil, false, fmt.Errorf("proto: bad default int64 %q: %v", prop.Default, err)
}
sf.value = x
case reflect.String:
sf.value = prop.Default
case reflect.Uint8:
// []byte (not *uint8)
sf.value = []byte(prop.Default)
case reflect.Uint32:
x, err := strconv.ParseUint(prop.Default, 10, 32)
if err != nil {
return nil, false, fmt.Errorf("proto: bad default uint32 %q: %v", prop.Default, err)
}
sf.value = uint32(x)
case reflect.Uint64:
x, err := strconv.ParseUint(prop.Default, 10, 64)
if err != nil {
return nil, false, fmt.Errorf("proto: bad default uint64 %q: %v", prop.Default, err)
}
sf.value = x
default:
return nil, false, fmt.Errorf("proto: unhandled def kind %v", ft.Elem().Kind())
}
return sf, false, nil
}
// mapKeys returns a sort.Interface to be used for sorting the map keys.
// Map fields may have key types of non-float scalars, strings and enums.
func mapKeys(vs []reflect.Value) sort.Interface {
s := mapKeySorter{vs: vs}
// Type specialization per https://developers.google.com/protocol-buffers/docs/proto#maps.
if len(vs) == 0 {
return s
}
switch vs[0].Kind() {
case reflect.Int32, reflect.Int64:
s.less = func(a, b reflect.Value) bool { return a.Int() < b.Int() }
case reflect.Uint32, reflect.Uint64:
s.less = func(a, b reflect.Value) bool { return a.Uint() < b.Uint() }
case reflect.Bool:
s.less = func(a, b reflect.Value) bool { return !a.Bool() && b.Bool() } // false < true
case reflect.String:
s.less = func(a, b reflect.Value) bool { return a.String() < b.String() }
default:
panic(fmt.Sprintf("unsupported map key type: %v", vs[0].Kind()))
}
return s
}
type mapKeySorter struct {
vs []reflect.Value
less func(a, b reflect.Value) bool
}
func (s mapKeySorter) Len() int { return len(s.vs) }
func (s mapKeySorter) Swap(i, j int) { s.vs[i], s.vs[j] = s.vs[j], s.vs[i] }
func (s mapKeySorter) Less(i, j int) bool {
return s.less(s.vs[i], s.vs[j])
}
// isProto3Zero reports whether v is a zero proto3 value.
func isProto3Zero(v reflect.Value) bool {
switch v.Kind() {
case reflect.Bool:
return !v.Bool()
case reflect.Int32, reflect.Int64:
return v.Int() == 0
case reflect.Uint32, reflect.Uint64:
return v.Uint() == 0
case reflect.Float32, reflect.Float64:
return v.Float() == 0
case reflect.String:
return v.String() == ""
}
return false
}
const (
// ProtoPackageIsVersion3 is referenced from generated protocol buffer files
// to assert that that code is compatible with this version of the proto package.
ProtoPackageIsVersion3 = true
// ProtoPackageIsVersion2 is referenced from generated protocol buffer files
// to assert that that code is compatible with this version of the proto package.
ProtoPackageIsVersion2 = true
// ProtoPackageIsVersion1 is referenced from generated protocol buffer files
// to assert that that code is compatible with this version of the proto package.
ProtoPackageIsVersion1 = true
)
// InternalMessageInfo is a type used internally by generated .pb.go files.
// This type is not intended to be used by non-generated code.
// This type is not subject to any compatibility guarantee.
type InternalMessageInfo struct {
marshal *marshalInfo
unmarshal *unmarshalInfo
merge *mergeInfo
discard *discardInfo
}

181
vendor/github.com/golang/protobuf/proto/message_set.go generated vendored
View file

@ -1,181 +0,0 @@
// Go support for Protocol Buffers - Google's data interchange format
//
// Copyright 2010 The Go Authors. All rights reserved.
// https://github.com/golang/protobuf
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
// * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
// * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following disclaimer
// in the documentation and/or other materials provided with the
// distribution.
// * Neither the name of Google Inc. nor the names of its
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
package proto
/*
* Support for message sets.
*/
import (
"errors"
)
// errNoMessageTypeID occurs when a protocol buffer does not have a message type ID.
// A message type ID is required for storing a protocol buffer in a message set.
var errNoMessageTypeID = errors.New("proto does not have a message type ID")
// The first two types (_MessageSet_Item and messageSet)
// model what the protocol compiler produces for the following protocol message:
// message MessageSet {
// repeated group Item = 1 {
// required int32 type_id = 2;
// required string message = 3;
// };
// }
// That is the MessageSet wire format. We can't use a proto to generate these
// because that would introduce a circular dependency between it and this package.
type _MessageSet_Item struct {
TypeId *int32 `protobuf:"varint,2,req,name=type_id"`
Message []byte `protobuf:"bytes,3,req,name=message"`
}
type messageSet struct {
Item []*_MessageSet_Item `protobuf:"group,1,rep"`
XXX_unrecognized []byte
// TODO: caching?
}
// Make sure messageSet is a Message.
var _ Message = (*messageSet)(nil)
// messageTypeIder is an interface satisfied by a protocol buffer type
// that may be stored in a MessageSet.
type messageTypeIder interface {
MessageTypeId() int32
}
func (ms *messageSet) find(pb Message) *_MessageSet_Item {
mti, ok := pb.(messageTypeIder)
if !ok {
return nil
}
id := mti.MessageTypeId()
for _, item := range ms.Item {
if *item.TypeId == id {
return item
}
}
return nil
}
func (ms *messageSet) Has(pb Message) bool {
return ms.find(pb) != nil
}
func (ms *messageSet) Unmarshal(pb Message) error {
if item := ms.find(pb); item != nil {
return Unmarshal(item.Message, pb)
}
if _, ok := pb.(messageTypeIder); !ok {
return errNoMessageTypeID
}
return nil // TODO: return error instead?
}
func (ms *messageSet) Marshal(pb Message) error {
msg, err := Marshal(pb)
if err != nil {
return err
}
if item := ms.find(pb); item != nil {
// reuse existing item
item.Message = msg
return nil
}
mti, ok := pb.(messageTypeIder)
if !ok {
return errNoMessageTypeID
}
mtid := mti.MessageTypeId()
ms.Item = append(ms.Item, &_MessageSet_Item{
TypeId: &mtid,
Message: msg,
})
return nil
}
func (ms *messageSet) Reset() { *ms = messageSet{} }
func (ms *messageSet) String() string { return CompactTextString(ms) }
func (*messageSet) ProtoMessage() {}
// Support for the message_set_wire_format message option.
func skipVarint(buf []byte) []byte {
i := 0
for ; buf[i]&0x80 != 0; i++ {
}
return buf[i+1:]
}
// unmarshalMessageSet decodes the extension map encoded in buf in the message set wire format.
// It is called by Unmarshal methods on protocol buffer messages with the message_set_wire_format option.
func unmarshalMessageSet(buf []byte, exts interface{}) error {
var m map[int32]Extension
switch exts := exts.(type) {
case *XXX_InternalExtensions:
m = exts.extensionsWrite()
case map[int32]Extension:
m = exts
default:
return errors.New("proto: not an extension map")
}
ms := new(messageSet)
if err := Unmarshal(buf, ms); err != nil {
return err
}
for _, item := range ms.Item {
id := *item.TypeId
msg := item.Message
// Restore wire type and field number varint, plus length varint.
// Be careful to preserve duplicate items.
b := EncodeVarint(uint64(id)<<3 | WireBytes)
if ext, ok := m[id]; ok {
// Existing data; rip off the tag and length varint
// so we join the new data correctly.
// We can assume that ext.enc is set because we are unmarshaling.
o := ext.enc[len(b):] // skip wire type and field number
_, n := DecodeVarint(o) // calculate length of length varint
o = o[n:] // skip length varint
msg = append(o, msg...) // join old data and new data
}
b = append(b, EncodeVarint(uint64(len(msg)))...)
b = append(b, msg...)
m[id] = Extension{enc: b}
}
return nil
}

360
vendor/github.com/golang/protobuf/proto/pointer_reflect.go generated vendored
View file

@ -1,360 +0,0 @@
// Go support for Protocol Buffers - Google's data interchange format
//
// Copyright 2012 The Go Authors. All rights reserved.
// https://github.com/golang/protobuf
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
// * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
// * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following disclaimer
// in the documentation and/or other materials provided with the
// distribution.
// * Neither the name of Google Inc. nor the names of its
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
// +build purego appengine js
// This file contains an implementation of proto field accesses using package reflect.
// It is slower than the code in pointer_unsafe.go but it avoids package unsafe and can
// be used on App Engine.
package proto
import (
"reflect"
"sync"
)
const unsafeAllowed = false
// A field identifies a field in a struct, accessible from a pointer.
// In this implementation, a field is identified by the sequence of field indices
// passed to reflect's FieldByIndex.
type field []int
// toField returns a field equivalent to the given reflect field.
func toField(f *reflect.StructField) field {
return f.Index
}
// invalidField is an invalid field identifier.
var invalidField = field(nil)
// zeroField is a noop when calling pointer.offset.
var zeroField = field([]int{})
// IsValid reports whether the field identifier is valid.
func (f field) IsValid() bool { return f != nil }
// The pointer type is for the table-driven decoder.
// The implementation here uses a reflect.Value of pointer type to
// create a generic pointer. In pointer_unsafe.go we use unsafe
// instead of reflect to implement the same (but faster) interface.
type pointer struct {
v reflect.Value
}
// toPointer converts an interface of pointer type to a pointer
// that points to the same target.
func toPointer(i *Message) pointer {
return pointer{v: reflect.ValueOf(*i)}
}
// toAddrPointer converts an interface to a pointer that points to
// the interface data.
func toAddrPointer(i *interface{}, isptr, deref bool) pointer {
v := reflect.ValueOf(*i)
u := reflect.New(v.Type())
u.Elem().Set(v)
if deref {
u = u.Elem()
}
return pointer{v: u}
}
// valToPointer converts v to a pointer. v must be of pointer type.
func valToPointer(v reflect.Value) pointer {
return pointer{v: v}
}
// offset converts from a pointer to a structure to a pointer to
// one of its fields.
func (p pointer) offset(f field) pointer {
return pointer{v: p.v.Elem().FieldByIndex(f).Addr()}
}
func (p pointer) isNil() bool {
return p.v.IsNil()
}
// grow updates the slice s in place to make it one element longer.
// s must be addressable.
// Returns the (addressable) new element.
func grow(s reflect.Value) reflect.Value {
n, m := s.Len(), s.Cap()
if n < m {
s.SetLen(n + 1)
} else {
s.Set(reflect.Append(s, reflect.Zero(s.Type().Elem())))
}
return s.Index(n)
}
func (p pointer) toInt64() *int64 {
return p.v.Interface().(*int64)
}
func (p pointer) toInt64Ptr() **int64 {
return p.v.Interface().(**int64)
}
func (p pointer) toInt64Slice() *[]int64 {
return p.v.Interface().(*[]int64)
}
var int32ptr = reflect.TypeOf((*int32)(nil))
func (p pointer) toInt32() *int32 {
return p.v.Convert(int32ptr).Interface().(*int32)
}
// The toInt32Ptr/Slice methods don't work because of enums.
// Instead, we must use set/get methods for the int32ptr/slice case.
/*
func (p pointer) toInt32Ptr() **int32 {
return p.v.Interface().(**int32)
}
func (p pointer) toInt32Slice() *[]int32 {
return p.v.Interface().(*[]int32)
}
*/
func (p pointer) getInt32Ptr() *int32 {
if p.v.Type().Elem().Elem() == reflect.TypeOf(int32(0)) {
// raw int32 type
return p.v.Elem().Interface().(*int32)
}
// an enum
return p.v.Elem().Convert(int32PtrType).Interface().(*int32)
}
func (p pointer) setInt32Ptr(v int32) {
// Allocate value in a *int32. Possibly convert that to a *enum.
// Then assign it to a **int32 or **enum.
// Note: we can convert *int32 to *enum, but we can't convert
// **int32 to **enum!
p.v.Elem().Set(reflect.ValueOf(&v).Convert(p.v.Type().Elem()))
}
// getInt32Slice copies []int32 from p as a new slice.
// This behavior differs from the implementation in pointer_unsafe.go.
func (p pointer) getInt32Slice() []int32 {
if p.v.Type().Elem().Elem() == reflect.TypeOf(int32(0)) {
// raw int32 type
return p.v.Elem().Interface().([]int32)
}
// an enum
// Allocate a []int32, then assign []enum's values into it.
// Note: we can't convert []enum to []int32.
slice := p.v.Elem()
s := make([]int32, slice.Len())
for i := 0; i < slice.Len(); i++ {
s[i] = int32(slice.Index(i).Int())
}
return s
}
// setInt32Slice copies []int32 into p as a new slice.
// This behavior differs from the implementation in pointer_unsafe.go.
func (p pointer) setInt32Slice(v []int32) {
if p.v.Type().Elem().Elem() == reflect.TypeOf(int32(0)) {
// raw int32 type
p.v.Elem().Set(reflect.ValueOf(v))
return
}
// an enum
// Allocate a []enum, then assign []int32's values into it.
// Note: we can't convert []enum to []int32.
slice := reflect.MakeSlice(p.v.Type().Elem(), len(v), cap(v))
for i, x := range v {
slice.Index(i).SetInt(int64(x))
}
p.v.Elem().Set(slice)
}
func (p pointer) appendInt32Slice(v int32) {
grow(p.v.Elem()).SetInt(int64(v))
}
func (p pointer) toUint64() *uint64 {
return p.v.Interface().(*uint64)
}
func (p pointer) toUint64Ptr() **uint64 {
return p.v.Interface().(**uint64)
}
func (p pointer) toUint64Slice() *[]uint64 {
return p.v.Interface().(*[]uint64)
}
func (p pointer) toUint32() *uint32 {
return p.v.Interface().(*uint32)
}
func (p pointer) toUint32Ptr() **uint32 {
return p.v.Interface().(**uint32)
}
func (p pointer) toUint32Slice() *[]uint32 {
return p.v.Interface().(*[]uint32)
}
func (p pointer) toBool() *bool {
return p.v.Interface().(*bool)
}
func (p pointer) toBoolPtr() **bool {
return p.v.Interface().(**bool)
}
func (p pointer) toBoolSlice() *[]bool {
return p.v.Interface().(*[]bool)
}
func (p pointer) toFloat64() *float64 {
return p.v.Interface().(*float64)
}
func (p pointer) toFloat64Ptr() **float64 {
return p.v.Interface().(**float64)
}
func (p pointer) toFloat64Slice() *[]float64 {
return p.v.Interface().(*[]float64)
}
func (p pointer) toFloat32() *float32 {
return p.v.Interface().(*float32)
}
func (p pointer) toFloat32Ptr() **float32 {
return p.v.Interface().(**float32)
}
func (p pointer) toFloat32Slice() *[]float32 {
return p.v.Interface().(*[]float32)
}
func (p pointer) toString() *string {
return p.v.Interface().(*string)
}
func (p pointer) toStringPtr() **string {
return p.v.Interface().(**string)
}
func (p pointer) toStringSlice() *[]string {
return p.v.Interface().(*[]string)
}
func (p pointer) toBytes() *[]byte {
return p.v.Interface().(*[]byte)
}
func (p pointer) toBytesSlice() *[][]byte {
return p.v.Interface().(*[][]byte)
}
func (p pointer) toExtensions() *XXX_InternalExtensions {
return p.v.Interface().(*XXX_InternalExtensions)
}
func (p pointer) toOldExtensions() *map[int32]Extension {
return p.v.Interface().(*map[int32]Extension)
}
func (p pointer) getPointer() pointer {
return pointer{v: p.v.Elem()}
}
func (p pointer) setPointer(q pointer) {
p.v.Elem().Set(q.v)
}
func (p pointer) appendPointer(q pointer) {
grow(p.v.Elem()).Set(q.v)
}
// getPointerSlice copies []*T from p as a new []pointer.
// This behavior differs from the implementation in pointer_unsafe.go.
func (p pointer) getPointerSlice() []pointer {
if p.v.IsNil() {
return nil
}
n := p.v.Elem().Len()
s := make([]pointer, n)
for i := 0; i < n; i++ {
s[i] = pointer{v: p.v.Elem().Index(i)}
}
return s
}
// setPointerSlice copies []pointer into p as a new []*T.
// This behavior differs from the implementation in pointer_unsafe.go.
func (p pointer) setPointerSlice(v []pointer) {
if v == nil {
p.v.Elem().Set(reflect.New(p.v.Elem().Type()).Elem())
return
}
s := reflect.MakeSlice(p.v.Elem().Type(), 0, len(v))
for _, p := range v {
s = reflect.Append(s, p.v)
}
p.v.Elem().Set(s)
}
// getInterfacePointer returns a pointer that points to the
// interface data of the interface pointed by p.
func (p pointer) getInterfacePointer() pointer {
if p.v.Elem().IsNil() {
return pointer{v: p.v.Elem()}
}
return pointer{v: p.v.Elem().Elem().Elem().Field(0).Addr()} // *interface -> interface -> *struct -> struct
}
func (p pointer) asPointerTo(t reflect.Type) reflect.Value {
// TODO: check that p.v.Type().Elem() == t?
return p.v
}
func atomicLoadUnmarshalInfo(p **unmarshalInfo) *unmarshalInfo {
atomicLock.Lock()
defer atomicLock.Unlock()
return *p
}
func atomicStoreUnmarshalInfo(p **unmarshalInfo, v *unmarshalInfo) {
atomicLock.Lock()
defer atomicLock.Unlock()
*p = v
}
func atomicLoadMarshalInfo(p **marshalInfo) *marshalInfo {
atomicLock.Lock()
defer atomicLock.Unlock()
return *p
}
func atomicStoreMarshalInfo(p **marshalInfo, v *marshalInfo) {
atomicLock.Lock()
defer atomicLock.Unlock()
*p = v
}
func atomicLoadMergeInfo(p **mergeInfo) *mergeInfo {
atomicLock.Lock()
defer atomicLock.Unlock()
return *p
}
func atomicStoreMergeInfo(p **mergeInfo, v *mergeInfo) {
atomicLock.Lock()
defer atomicLock.Unlock()
*p = v
}
func atomicLoadDiscardInfo(p **discardInfo) *discardInfo {
atomicLock.Lock()
defer atomicLock.Unlock()
return *p
}
func atomicStoreDiscardInfo(p **discardInfo, v *discardInfo) {
atomicLock.Lock()
defer atomicLock.Unlock()
*p = v
}
var atomicLock sync.Mutex

313
vendor/github.com/golang/protobuf/proto/pointer_unsafe.go generated vendored
View file

@ -1,313 +0,0 @@
// Go support for Protocol Buffers - Google's data interchange format
//
// Copyright 2012 The Go Authors. All rights reserved.
// https://github.com/golang/protobuf
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
// * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
// * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following disclaimer
// in the documentation and/or other materials provided with the
// distribution.
// * Neither the name of Google Inc. nor the names of its
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
// +build !purego,!appengine,!js
// This file contains the implementation of the proto field accesses using package unsafe.
package proto
import (
"reflect"
"sync/atomic"
"unsafe"
)
const unsafeAllowed = true
// A field identifies a field in a struct, accessible from a pointer.
// In this implementation, a field is identified by its byte offset from the start of the struct.
type field uintptr
// toField returns a field equivalent to the given reflect field.
func toField(f *reflect.StructField) field {
return field(f.Offset)
}
// invalidField is an invalid field identifier.
const invalidField = ^field(0)
// zeroField is a noop when calling pointer.offset.
const zeroField = field(0)
// IsValid reports whether the field identifier is valid.
func (f field) IsValid() bool {
return f != invalidField
}
// The pointer type below is for the new table-driven encoder/decoder.
// The implementation here uses unsafe.Pointer to create a generic pointer.
// In pointer_reflect.go we use reflect instead of unsafe to implement
// the same (but slower) interface.
type pointer struct {
p unsafe.Pointer
}
// size of pointer
var ptrSize = unsafe.Sizeof(uintptr(0))
// toPointer converts an interface of pointer type to a pointer
// that points to the same target.
func toPointer(i *Message) pointer {
// Super-tricky - read pointer out of data word of interface value.
// Saves ~25ns over the equivalent:
// return valToPointer(reflect.ValueOf(*i))
return pointer{p: (*[2]unsafe.Pointer)(unsafe.Pointer(i))[1]}
}
// toAddrPointer converts an interface to a pointer that points to
// the interface data.
func toAddrPointer(i *interface{}, isptr, deref bool) (p pointer) {
// Super-tricky - read or get the address of data word of interface value.
if isptr {
// The interface is of pointer type, thus it is a direct interface.
// The data word is the pointer data itself. We take its address.
p = pointer{p: unsafe.Pointer(uintptr(unsafe.Pointer(i)) + ptrSize)}
} else {
// The interface is not of pointer type. The data word is the pointer
// to the data.
p = pointer{p: (*[2]unsafe.Pointer)(unsafe.Pointer(i))[1]}
}
if deref {
p.p = *(*unsafe.Pointer)(p.p)
}
return p
}
// valToPointer converts v to a pointer. v must be of pointer type.
func valToPointer(v reflect.Value) pointer {
return pointer{p: unsafe.Pointer(v.Pointer())}
}
// offset converts from a pointer to a structure to a pointer to
// one of its fields.
func (p pointer) offset(f field) pointer {
// For safety, we should panic if !f.IsValid, however calling panic causes
// this to no longer be inlineable, which is a serious performance cost.
/*
if !f.IsValid() {
panic("invalid field")
}
*/
return pointer{p: unsafe.Pointer(uintptr(p.p) + uintptr(f))}
}
func (p pointer) isNil() bool {
return p.p == nil
}
func (p pointer) toInt64() *int64 {
return (*int64)(p.p)
}
func (p pointer) toInt64Ptr() **int64 {
return (**int64)(p.p)
}
func (p pointer) toInt64Slice() *[]int64 {
return (*[]int64)(p.p)
}
func (p pointer) toInt32() *int32 {
return (*int32)(p.p)
}
// See pointer_reflect.go for why toInt32Ptr/Slice doesn't exist.
/*
func (p pointer) toInt32Ptr() **int32 {
return (**int32)(p.p)
}
func (p pointer) toInt32Slice() *[]int32 {
return (*[]int32)(p.p)
}
*/
func (p pointer) getInt32Ptr() *int32 {
return *(**int32)(p.p)
}
func (p pointer) setInt32Ptr(v int32) {
*(**int32)(p.p) = &v
}
// getInt32Slice loads a []int32 from p.
// The value returned is aliased with the original slice.
// This behavior differs from the implementation in pointer_reflect.go.
func (p pointer) getInt32Slice() []int32 {
return *(*[]int32)(p.p)
}
// setInt32Slice stores a []int32 to p.
// The value set is aliased with the input slice.
// This behavior differs from the implementation in pointer_reflect.go.
func (p pointer) setInt32Slice(v []int32) {
*(*[]int32)(p.p) = v
}
// TODO: Can we get rid of appendInt32Slice and use setInt32Slice instead?
func (p pointer) appendInt32Slice(v int32) {
s := (*[]int32)(p.p)
*s = append(*s, v)
}
func (p pointer) toUint64() *uint64 {
return (*uint64)(p.p)
}
func (p pointer) toUint64Ptr() **uint64 {
return (**uint64)(p.p)
}
func (p pointer) toUint64Slice() *[]uint64 {
return (*[]uint64)(p.p)
}
func (p pointer) toUint32() *uint32 {
return (*uint32)(p.p)
}
func (p pointer) toUint32Ptr() **uint32 {
return (**uint32)(p.p)
}
func (p pointer) toUint32Slice() *[]uint32 {
return (*[]uint32)(p.p)
}
func (p pointer) toBool() *bool {
return (*bool)(p.p)
}
func (p pointer) toBoolPtr() **bool {
return (**bool)(p.p)
}
func (p pointer) toBoolSlice() *[]bool {
return (*[]bool)(p.p)
}
func (p pointer) toFloat64() *float64 {
return (*float64)(p.p)
}
func (p pointer) toFloat64Ptr() **float64 {
return (**float64)(p.p)
}
func (p pointer) toFloat64Slice() *[]float64 {
return (*[]float64)(p.p)
}
func (p pointer) toFloat32() *float32 {
return (*float32)(p.p)
}
func (p pointer) toFloat32Ptr() **float32 {
return (**float32)(p.p)
}
func (p pointer) toFloat32Slice() *[]float32 {
return (*[]float32)(p.p)
}
func (p pointer) toString() *string {
return (*string)(p.p)
}
func (p pointer) toStringPtr() **string {
return (**string)(p.p)
}
func (p pointer) toStringSlice() *[]string {
return (*[]string)(p.p)
}
func (p pointer) toBytes() *[]byte {
return (*[]byte)(p.p)
}
func (p pointer) toBytesSlice() *[][]byte {
return (*[][]byte)(p.p)
}
func (p pointer) toExtensions() *XXX_InternalExtensions {
return (*XXX_InternalExtensions)(p.p)
}
func (p pointer) toOldExtensions() *map[int32]Extension {
return (*map[int32]Extension)(p.p)
}
// getPointerSlice loads []*T from p as a []pointer.
// The value returned is aliased with the original slice.
// This behavior differs from the implementation in pointer_reflect.go.
func (p pointer) getPointerSlice() []pointer {
// Super-tricky - p should point to a []*T where T is a
// message type. We load it as []pointer.
return *(*[]pointer)(p.p)
}
// setPointerSlice stores []pointer into p as a []*T.
// The value set is aliased with the input slice.
// This behavior differs from the implementation in pointer_reflect.go.
func (p pointer) setPointerSlice(v []pointer) {
// Super-tricky - p should point to a []*T where T is a
// message type. We store it as []pointer.
*(*[]pointer)(p.p) = v
}
// getPointer loads the pointer at p and returns it.
func (p pointer) getPointer() pointer {
return pointer{p: *(*unsafe.Pointer)(p.p)}
}
// setPointer stores the pointer q at p.
func (p pointer) setPointer(q pointer) {
*(*unsafe.Pointer)(p.p) = q.p
}
// append q to the slice pointed to by p.
func (p pointer) appendPointer(q pointer) {
s := (*[]unsafe.Pointer)(p.p)
*s = append(*s, q.p)
}
// getInterfacePointer returns a pointer that points to the
// interface data of the interface pointed by p.
func (p pointer) getInterfacePointer() pointer {
// Super-tricky - read pointer out of data word of interface value.
return pointer{p: (*(*[2]unsafe.Pointer)(p.p))[1]}
}
// asPointerTo returns a reflect.Value that is a pointer to an
// object of type t stored at p.
func (p pointer) asPointerTo(t reflect.Type) reflect.Value {
return reflect.NewAt(t, p.p)
}
func atomicLoadUnmarshalInfo(p **unmarshalInfo) *unmarshalInfo {
return (*unmarshalInfo)(atomic.LoadPointer((*unsafe.Pointer)(unsafe.Pointer(p))))
}
func atomicStoreUnmarshalInfo(p **unmarshalInfo, v *unmarshalInfo) {
atomic.StorePointer((*unsafe.Pointer)(unsafe.Pointer(p)), unsafe.Pointer(v))
}
func atomicLoadMarshalInfo(p **marshalInfo) *marshalInfo {
return (*marshalInfo)(atomic.LoadPointer((*unsafe.Pointer)(unsafe.Pointer(p))))
}
func atomicStoreMarshalInfo(p **marshalInfo, v *marshalInfo) {
atomic.StorePointer((*unsafe.Pointer)(unsafe.Pointer(p)), unsafe.Pointer(v))
}
func atomicLoadMergeInfo(p **mergeInfo) *mergeInfo {
return (*mergeInfo)(atomic.LoadPointer((*unsafe.Pointer)(unsafe.Pointer(p))))
}
func atomicStoreMergeInfo(p **mergeInfo, v *mergeInfo) {
atomic.StorePointer((*unsafe.Pointer)(unsafe.Pointer(p)), unsafe.Pointer(v))
}
func atomicLoadDiscardInfo(p **discardInfo) *discardInfo {
return (*discardInfo)(atomic.LoadPointer((*unsafe.Pointer)(unsafe.Pointer(p))))
}
func atomicStoreDiscardInfo(p **discardInfo, v *discardInfo) {
atomic.StorePointer((*unsafe.Pointer)(unsafe.Pointer(p)), unsafe.Pointer(v))
}

652
vendor/github.com/golang/protobuf/proto/properties.go generated vendored
View file

@ -1,162 +1,104 @@
// Go support for Protocol Buffers - Google's data interchange format
//
// Copyright 2010 The Go Authors. All rights reserved.
// https://github.com/golang/protobuf
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
// * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
// * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following disclaimer
// in the documentation and/or other materials provided with the
// distribution.
// * Neither the name of Google Inc. nor the names of its
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
// Copyright 2010 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
package proto
/*
* Routines for encoding data into the wire format for protocol buffers.
*/
import (
"fmt"
"log"
"reflect"
"sort"
"strconv"
"strings"
"sync"
"google.golang.org/protobuf/reflect/protoreflect"
"google.golang.org/protobuf/runtime/protoimpl"
)
const debug bool = false
// Constants that identify the encoding of a value on the wire.
const (
WireVarint = 0
WireFixed64 = 1
WireBytes = 2
WireStartGroup = 3
WireEndGroup = 4
WireFixed32 = 5
)
// tagMap is an optimization over map[int]int for typical protocol buffer
// use-cases. Encoded protocol buffers are often in tag order with small tag
// numbers.
type tagMap struct {
fastTags []int
slowTags map[int]int
}
// tagMapFastLimit is the upper bound on the tag number that will be stored in
// the tagMap slice rather than its map.
const tagMapFastLimit = 1024
func (p *tagMap) get(t int) (int, bool) {
if t > 0 && t < tagMapFastLimit {
if t >= len(p.fastTags) {
return 0, false
}
fi := p.fastTags[t]
return fi, fi >= 0
}
fi, ok := p.slowTags[t]
return fi, ok
}
func (p *tagMap) put(t int, fi int) {
if t > 0 && t < tagMapFastLimit {
for len(p.fastTags) < t+1 {
p.fastTags = append(p.fastTags, -1)
}
p.fastTags[t] = fi
return
}
if p.slowTags == nil {
p.slowTags = make(map[int]int)
}
p.slowTags[t] = fi
}
// StructProperties represents properties for all the fields of a struct.
// decoderTags and decoderOrigNames should only be used by the decoder.
// StructProperties represents protocol buffer type information for a
// generated protobuf message in the open-struct API.
//
// Deprecated: Do not use.
type StructProperties struct {
Prop []*Properties // properties for each field
reqCount int // required count
decoderTags tagMap // map from proto tag to struct field number
decoderOrigNames map[string]int // map from original name to struct field number
order []int // list of struct field numbers in tag order
// Prop are the properties for each field.
//
// Fields belonging to a oneof are stored in OneofTypes instead, with a
// single Properties representing the parent oneof held here.
//
// The order of Prop matches the order of fields in the Go struct.
// Struct fields that are not related to protobufs have a "XXX_" prefix
// in the Properties.Name and must be ignored by the user.
Prop []*Properties
// OneofTypes contains information about the oneof fields in this message.
// It is keyed by the original name of a field.
// It is keyed by the protobuf field name.
OneofTypes map[string]*OneofProperties
}
// OneofProperties represents information about a specific field in a oneof.
type OneofProperties struct {
Type reflect.Type // pointer to generated struct type for this oneof field
Field int // struct field number of the containing oneof in the message
Prop *Properties
}
// Implement the sorting interface so we can sort the fields in tag order, as recommended by the spec.
// See encode.go, (*Buffer).enc_struct.
func (sp *StructProperties) Len() int { return len(sp.order) }
func (sp *StructProperties) Less(i, j int) bool {
return sp.Prop[sp.order[i]].Tag < sp.Prop[sp.order[j]].Tag
}
func (sp *StructProperties) Swap(i, j int) { sp.order[i], sp.order[j] = sp.order[j], sp.order[i] }
// Properties represents the protocol-specific behavior of a single struct field.
// Properties represents the type information for a protobuf message field.
//
// Deprecated: Do not use.
type Properties struct {
Name string // name of the field, for error messages
OrigName string // original name before protocol compiler (always set)
JSONName string // name to use for JSON; determined by protoc
Wire string
// Name is a placeholder name with little meaningful semantic value.
// If the name has an "XXX_" prefix, the entire Properties must be ignored.
Name string
// OrigName is the protobuf field name or oneof name.
OrigName string
// JSONName is the JSON name for the protobuf field.
JSONName string
// Enum is a placeholder name for enums.
// For historical reasons, this is neither the Go name for the enum,
// nor the protobuf name for the enum.
Enum string // Deprecated: Do not use.
// Weak contains the full name of the weakly referenced message.
Weak string
// Wire is a string representation of the wire type.
Wire string
// WireType is the protobuf wire type for the field.
WireType int
Tag int
// Tag is the protobuf field number.
Tag int
// Required reports whether this is a required field.
Required bool
// Optional reports whether this is a optional field.
Optional bool
// Repeated reports whether this is a repeated field.
Repeated bool
Packed bool // relevant for repeated primitives only
Enum string // set for enum types only
proto3 bool // whether this is known to be a proto3 field
oneof bool // whether this is a oneof field
// Packed reports whether this is a packed repeated field of scalars.
Packed bool
// Proto3 reports whether this field operates under the proto3 syntax.
Proto3 bool
// Oneof reports whether this field belongs within a oneof.
Oneof bool
Default string // default value
HasDefault bool // whether an explicit default was provided
// Default is the default value in string form.
Default string
// HasDefault reports whether the field has a default value.
HasDefault bool
stype reflect.Type // set for struct types only
sprop *StructProperties // set for struct types only
// MapKeyProp is the properties for the key field for a map field.
MapKeyProp *Properties
// MapValProp is the properties for the value field for a map field.
MapValProp *Properties
}
mtype reflect.Type // set for map types only
MapKeyProp *Properties // set for map types only
MapValProp *Properties // set for map types only
// OneofProperties represents the type information for a protobuf oneof.
//
// Deprecated: Do not use.
type OneofProperties struct {
// Type is a pointer to the generated wrapper type for the field value.
// This is nil for messages that are not in the open-struct API.
Type reflect.Type
// Field is the index into StructProperties.Prop for the containing oneof.
Field int
// Prop is the properties for the field.
Prop *Properties
}
// String formats the properties in the protobuf struct field tag style.
func (p *Properties) String() string {
s := p.Wire
s += ","
s += strconv.Itoa(p.Tag)
s += "," + strconv.Itoa(p.Tag)
if p.Required {
s += ",req"
}
@ -170,18 +112,21 @@ func (p *Properties) String() string {
s += ",packed"
}
s += ",name=" + p.OrigName
if p.JSONName != p.OrigName {
if p.JSONName != "" {
s += ",json=" + p.JSONName
}
if p.proto3 {
s += ",proto3"
}
if p.oneof {
s += ",oneof"
}
if len(p.Enum) > 0 {
s += ",enum=" + p.Enum
}
if len(p.Weak) > 0 {
s += ",weak=" + p.Weak
}
if p.Proto3 {
s += ",proto3"
}
if p.Oneof {
s += ",oneof"
}
if p.HasDefault {
s += ",def=" + p.Default
}
@ -189,356 +134,173 @@ func (p *Properties) String() string {
}
// Parse populates p by parsing a string in the protobuf struct field tag style.
func (p *Properties) Parse(s string) {
// "bytes,49,opt,name=foo,def=hello!"
fields := strings.Split(s, ",") // breaks def=, but handled below.
if len(fields) < 2 {
log.Printf("proto: tag has too few fields: %q", s)
return
}
p.Wire = fields[0]
switch p.Wire {
case "varint":
p.WireType = WireVarint
case "fixed32":
p.WireType = WireFixed32
case "fixed64":
p.WireType = WireFixed64
case "zigzag32":
p.WireType = WireVarint
case "zigzag64":
p.WireType = WireVarint
case "bytes", "group":
p.WireType = WireBytes
// no numeric converter for non-numeric types
default:
log.Printf("proto: tag has unknown wire type: %q", s)
return
}
var err error
p.Tag, err = strconv.Atoi(fields[1])
if err != nil {
return
}
outer:
for i := 2; i < len(fields); i++ {
f := fields[i]
switch {
case f == "req":
p.Required = true
case f == "opt":
func (p *Properties) Parse(tag string) {
// For example: "bytes,49,opt,name=foo,def=hello!"
for len(tag) > 0 {
i := strings.IndexByte(tag, ',')
if i < 0 {
i = len(tag)
}
switch s := tag[:i]; {
case strings.HasPrefix(s, "name="):
p.OrigName = s[len("name="):]
case strings.HasPrefix(s, "json="):
p.JSONName = s[len("json="):]
case strings.HasPrefix(s, "enum="):
p.Enum = s[len("enum="):]
case strings.HasPrefix(s, "weak="):
p.Weak = s[len("weak="):]
case strings.Trim(s, "0123456789") == "":
n, _ := strconv.ParseUint(s, 10, 32)
p.Tag = int(n)
case s == "opt":
p.Optional = true
case f == "rep":
case s == "req":
p.Required = true
case s == "rep":
p.Repeated = true
case f == "packed":
case s == "varint" || s == "zigzag32" || s == "zigzag64":
p.Wire = s
p.WireType = WireVarint
case s == "fixed32":
p.Wire = s
p.WireType = WireFixed32
case s == "fixed64":
p.Wire = s
p.WireType = WireFixed64
case s == "bytes":
p.Wire = s
p.WireType = WireBytes
case s == "group":
p.Wire = s
p.WireType = WireStartGroup
case s == "packed":
p.Packed = true
case strings.HasPrefix(f, "name="):
p.OrigName = f[5:]
case strings.HasPrefix(f, "json="):
p.JSONName = f[5:]
case strings.HasPrefix(f, "enum="):
p.Enum = f[5:]
case f == "proto3":
p.proto3 = true
case f == "oneof":
p.oneof = true
case strings.HasPrefix(f, "def="):
case s == "proto3":
p.Proto3 = true
case s == "oneof":
p.Oneof = true
case strings.HasPrefix(s, "def="):
// The default tag is special in that everything afterwards is the
// default regardless of the presence of commas.
p.HasDefault = true
p.Default = f[4:] // rest of string
if i+1 < len(fields) {
// Commas aren't escaped, and def is always last.
p.Default += "," + strings.Join(fields[i+1:], ",")
break outer
}
p.Default, i = tag[len("def="):], len(tag)
}
tag = strings.TrimPrefix(tag[i:], ",")
}
}
var protoMessageType = reflect.TypeOf((*Message)(nil)).Elem()
// setFieldProps initializes the field properties for submessages and maps.
func (p *Properties) setFieldProps(typ reflect.Type, f *reflect.StructField, lockGetProp bool) {
switch t1 := typ; t1.Kind() {
case reflect.Ptr:
if t1.Elem().Kind() == reflect.Struct {
p.stype = t1.Elem()
}
case reflect.Slice:
if t2 := t1.Elem(); t2.Kind() == reflect.Ptr && t2.Elem().Kind() == reflect.Struct {
p.stype = t2.Elem()
}
case reflect.Map:
p.mtype = t1
p.MapKeyProp = &Properties{}
p.MapKeyProp.init(reflect.PtrTo(p.mtype.Key()), "Key", f.Tag.Get("protobuf_key"), nil, lockGetProp)
p.MapValProp = &Properties{}
vtype := p.mtype.Elem()
if vtype.Kind() != reflect.Ptr && vtype.Kind() != reflect.Slice {
// The value type is not a message (*T) or bytes ([]byte),
// so we need encoders for the pointer to this type.
vtype = reflect.PtrTo(vtype)
}
p.MapValProp.init(vtype, "Value", f.Tag.Get("protobuf_val"), nil, lockGetProp)
}
if p.stype != nil {
if lockGetProp {
p.sprop = GetProperties(p.stype)
} else {
p.sprop = getPropertiesLocked(p.stype)
}
}
}
var (
marshalerType = reflect.TypeOf((*Marshaler)(nil)).Elem()
)
// Init populates the properties from a protocol buffer struct tag.
//
// Deprecated: Do not use.
func (p *Properties) Init(typ reflect.Type, name, tag string, f *reflect.StructField) {
p.init(typ, name, tag, f, true)
}
func (p *Properties) init(typ reflect.Type, name, tag string, f *reflect.StructField, lockGetProp bool) {
// "bytes,49,opt,def=hello!"
p.Name = name
p.OrigName = name
if tag == "" {
return
}
p.Parse(tag)
p.setFieldProps(typ, f, lockGetProp)
if typ != nil && typ.Kind() == reflect.Map {
p.MapKeyProp = new(Properties)
p.MapKeyProp.Init(nil, "Key", f.Tag.Get("protobuf_key"), nil)
p.MapValProp = new(Properties)
p.MapValProp.Init(nil, "Value", f.Tag.Get("protobuf_val"), nil)
}
}
var (
propertiesMu sync.RWMutex
propertiesMap = make(map[reflect.Type]*StructProperties)
)
var propertiesCache sync.Map // map[reflect.Type]*StructProperties
// GetProperties returns the list of properties for the type represented by t.
// t must represent a generated struct type of a protocol message.
// GetProperties returns the list of properties for the type represented by t,
// which must be a generated protocol buffer message in the open-struct API,
// where protobuf message fields are represented by exported Go struct fields.
//
// Deprecated: Use protobuf reflection instead.
func GetProperties(t reflect.Type) *StructProperties {
if t.Kind() != reflect.Struct {
panic("proto: type must have kind struct")
if p, ok := propertiesCache.Load(t); ok {
return p.(*StructProperties)
}
// Most calls to GetProperties in a long-running program will be
// retrieving details for types we have seen before.
propertiesMu.RLock()
sprop, ok := propertiesMap[t]
propertiesMu.RUnlock()
if ok {
return sprop
}
propertiesMu.Lock()
sprop = getPropertiesLocked(t)
propertiesMu.Unlock()
return sprop
p, _ := propertiesCache.LoadOrStore(t, newProperties(t))
return p.(*StructProperties)
}
type (
oneofFuncsIface interface {
XXX_OneofFuncs() (func(Message, *Buffer) error, func(Message, int, int, *Buffer) (bool, error), func(Message) int, []interface{})
}
oneofWrappersIface interface {
XXX_OneofWrappers() []interface{}
}
)
// getPropertiesLocked requires that propertiesMu is held.
func getPropertiesLocked(t reflect.Type) *StructProperties {
if prop, ok := propertiesMap[t]; ok {
return prop
func newProperties(t reflect.Type) *StructProperties {
if t.Kind() != reflect.Struct {
panic(fmt.Sprintf("%v is not a generated message in the open-struct API", t))
}
var hasOneof bool
prop := new(StructProperties)
// in case of recursive protos, fill this in now.
propertiesMap[t] = prop
// build properties
prop.Prop = make([]*Properties, t.NumField())
prop.order = make([]int, t.NumField())
// Construct a list of properties for each field in the struct.
for i := 0; i < t.NumField(); i++ {
f := t.Field(i)
p := new(Properties)
name := f.Name
p.init(f.Type, name, f.Tag.Get("protobuf"), &f, false)
f := t.Field(i)
tagField := f.Tag.Get("protobuf")
p.Init(f.Type, f.Name, tagField, &f)
oneof := f.Tag.Get("protobuf_oneof") // special case
if oneof != "" {
// Oneof fields don't use the traditional protobuf tag.
p.OrigName = oneof
tagOneof := f.Tag.Get("protobuf_oneof")
if tagOneof != "" {
hasOneof = true
p.OrigName = tagOneof
}
prop.Prop[i] = p
prop.order[i] = i
if debug {
print(i, " ", f.Name, " ", t.String(), " ")
if p.Tag > 0 {
print(p.String())
// Rename unrelated struct fields with the "XXX_" prefix since so much
// user code simply checks for this to exclude special fields.
if tagField == "" && tagOneof == "" && !strings.HasPrefix(p.Name, "XXX_") {
p.Name = "XXX_" + p.Name
p.OrigName = "XXX_" + p.OrigName
} else if p.Weak != "" {
p.Name = p.OrigName // avoid possible "XXX_" prefix on weak field
}
prop.Prop = append(prop.Prop, p)
}
// Construct a mapping of oneof field names to properties.
if hasOneof {
var oneofWrappers []interface{}
if fn, ok := reflect.PtrTo(t).MethodByName("XXX_OneofFuncs"); ok {
oneofWrappers = fn.Func.Call([]reflect.Value{reflect.Zero(fn.Type.In(0))})[3].Interface().([]interface{})
}
if fn, ok := reflect.PtrTo(t).MethodByName("XXX_OneofWrappers"); ok {
oneofWrappers = fn.Func.Call([]reflect.Value{reflect.Zero(fn.Type.In(0))})[0].Interface().([]interface{})
}
if m, ok := reflect.Zero(reflect.PtrTo(t)).Interface().(protoreflect.ProtoMessage); ok {
if m, ok := m.ProtoReflect().(interface{ ProtoMessageInfo() *protoimpl.MessageInfo }); ok {
oneofWrappers = m.ProtoMessageInfo().OneofWrappers
}
print("\n")
}
}
// Re-order prop.order.
sort.Sort(prop)
var oots []interface{}
switch m := reflect.Zero(reflect.PtrTo(t)).Interface().(type) {
case oneofFuncsIface:
_, _, _, oots = m.XXX_OneofFuncs()
case oneofWrappersIface:
oots = m.XXX_OneofWrappers()
}
if len(oots) > 0 {
// Interpret oneof metadata.
prop.OneofTypes = make(map[string]*OneofProperties)
for _, oot := range oots {
oop := &OneofProperties{
Type: reflect.ValueOf(oot).Type(), // *T
for _, wrapper := range oneofWrappers {
p := &OneofProperties{
Type: reflect.ValueOf(wrapper).Type(), // *T
Prop: new(Properties),
}
sft := oop.Type.Elem().Field(0)
oop.Prop.Name = sft.Name
oop.Prop.Parse(sft.Tag.Get("protobuf"))
// There will be exactly one interface field that
// this new value is assignable to.
for i := 0; i < t.NumField(); i++ {
f := t.Field(i)
if f.Type.Kind() != reflect.Interface {
continue
}
if !oop.Type.AssignableTo(f.Type) {
continue
}
oop.Field = i
break
}
prop.OneofTypes[oop.Prop.OrigName] = oop
}
}
f := p.Type.Elem().Field(0)
p.Prop.Name = f.Name
p.Prop.Parse(f.Tag.Get("protobuf"))
// build required counts
// build tags
reqCount := 0
prop.decoderOrigNames = make(map[string]int)
for i, p := range prop.Prop {
if strings.HasPrefix(p.Name, "XXX_") {
// Internal fields should not appear in tags/origNames maps.
// They are handled specially when encoding and decoding.
continue
// Determine the struct field that contains this oneof.
// Each wrapper is assignable to exactly one parent field.
var foundOneof bool
for i := 0; i < t.NumField() && !foundOneof; i++ {
if p.Type.AssignableTo(t.Field(i).Type) {
p.Field = i
foundOneof = true
}
}
if !foundOneof {
panic(fmt.Sprintf("%v is not a generated message in the open-struct API", t))
}
prop.OneofTypes[p.Prop.OrigName] = p
}
if p.Required {
reqCount++
}
prop.decoderTags.put(p.Tag, i)
prop.decoderOrigNames[p.OrigName] = i
}
prop.reqCount = reqCount
return prop
}
// A global registry of enum types.
// The generated code will register the generated maps by calling RegisterEnum.
var enumValueMaps = make(map[string]map[string]int32)
// RegisterEnum is called from the generated code to install the enum descriptor
// maps into the global table to aid parsing text format protocol buffers.
func RegisterEnum(typeName string, unusedNameMap map[int32]string, valueMap map[string]int32) {
if _, ok := enumValueMaps[typeName]; ok {
panic("proto: duplicate enum registered: " + typeName)
}
enumValueMaps[typeName] = valueMap
}
// EnumValueMap returns the mapping from names to integers of the
// enum type enumType, or a nil if not found.
func EnumValueMap(enumType string) map[string]int32 {
return enumValueMaps[enumType]
}
// A registry of all linked message types.
// The string is a fully-qualified proto name ("pkg.Message").
var (
protoTypedNils = make(map[string]Message) // a map from proto names to typed nil pointers
protoMapTypes = make(map[string]reflect.Type) // a map from proto names to map types
revProtoTypes = make(map[reflect.Type]string)
)
// RegisterType is called from generated code and maps from the fully qualified
// proto name to the type (pointer to struct) of the protocol buffer.
func RegisterType(x Message, name string) {
if _, ok := protoTypedNils[name]; ok {
// TODO: Some day, make this a panic.
log.Printf("proto: duplicate proto type registered: %s", name)
return
}
t := reflect.TypeOf(x)
if v := reflect.ValueOf(x); v.Kind() == reflect.Ptr && v.Pointer() == 0 {
// Generated code always calls RegisterType with nil x.
// This check is just for extra safety.
protoTypedNils[name] = x
} else {
protoTypedNils[name] = reflect.Zero(t).Interface().(Message)
}
revProtoTypes[t] = name
}
// RegisterMapType is called from generated code and maps from the fully qualified
// proto name to the native map type of the proto map definition.
func RegisterMapType(x interface{}, name string) {
if reflect.TypeOf(x).Kind() != reflect.Map {
panic(fmt.Sprintf("RegisterMapType(%T, %q); want map", x, name))
}
if _, ok := protoMapTypes[name]; ok {
log.Printf("proto: duplicate proto type registered: %s", name)
return
}
t := reflect.TypeOf(x)
protoMapTypes[name] = t
revProtoTypes[t] = name
}
// MessageName returns the fully-qualified proto name for the given message type.
func MessageName(x Message) string {
type xname interface {
XXX_MessageName() string
}
if m, ok := x.(xname); ok {
return m.XXX_MessageName()
}
return revProtoTypes[reflect.TypeOf(x)]
}
// MessageType returns the message type (pointer to struct) for a named message.
// The type is not guaranteed to implement proto.Message if the name refers to a
// map entry.
func MessageType(name string) reflect.Type {
if t, ok := protoTypedNils[name]; ok {
return reflect.TypeOf(t)
}
return protoMapTypes[name]
}
// A registry of all linked proto files.
var (
protoFiles = make(map[string][]byte) // file name => fileDescriptor
)
// RegisterFile is called from generated code and maps from the
// full file name of a .proto file to its compressed FileDescriptorProto.
func RegisterFile(filename string, fileDescriptor []byte) {
protoFiles[filename] = fileDescriptor
}
// FileDescriptor returns the compressed FileDescriptorProto for a .proto file.
func FileDescriptor(filename string) []byte { return protoFiles[filename] }
func (sp *StructProperties) Len() int { return len(sp.Prop) }
func (sp *StructProperties) Less(i, j int) bool { return false }
func (sp *StructProperties) Swap(i, j int) { return }

167
vendor/github.com/golang/protobuf/proto/proto.go generated vendored Normal file
View file

@ -0,0 +1,167 @@
// Copyright 2019 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
// Package proto provides functionality for handling protocol buffer messages.
// In particular, it provides marshaling and unmarshaling between a protobuf
// message and the binary wire format.
//
// See https://developers.google.com/protocol-buffers/docs/gotutorial for
// more information.
//
// Deprecated: Use the "google.golang.org/protobuf/proto" package instead.
package proto
import (
protoV2 "google.golang.org/protobuf/proto"
"google.golang.org/protobuf/reflect/protoreflect"
"google.golang.org/protobuf/runtime/protoiface"
"google.golang.org/protobuf/runtime/protoimpl"
)
const (
ProtoPackageIsVersion1 = true
ProtoPackageIsVersion2 = true
ProtoPackageIsVersion3 = true
ProtoPackageIsVersion4 = true
)
// GeneratedEnum is any enum type generated by protoc-gen-go
// which is a named int32 kind.
// This type exists for documentation purposes.
type GeneratedEnum interface{}
// GeneratedMessage is any message type generated by protoc-gen-go
// which is a pointer to a named struct kind.
// This type exists for documentation purposes.
type GeneratedMessage interface{}
// Message is a protocol buffer message.
//
// This is the v1 version of the message interface and is marginally better
// than an empty interface as it lacks any method to programatically interact
// with the contents of the message.
//
// A v2 message is declared in "google.golang.org/protobuf/proto".Message and
// exposes protobuf reflection as a first-class feature of the interface.
//
// To convert a v1 message to a v2 message, use the MessageV2 function.
// To convert a v2 message to a v1 message, use the MessageV1 function.
type Message = protoiface.MessageV1
// MessageV1 converts either a v1 or v2 message to a v1 message.
// It returns nil if m is nil.
func MessageV1(m GeneratedMessage) protoiface.MessageV1 {
return protoimpl.X.ProtoMessageV1Of(m)
}
// MessageV2 converts either a v1 or v2 message to a v2 message.
// It returns nil if m is nil.
func MessageV2(m GeneratedMessage) protoV2.Message {
return protoimpl.X.ProtoMessageV2Of(m)
}
// MessageReflect returns a reflective view for a message.
// It returns nil if m is nil.
func MessageReflect(m Message) protoreflect.Message {
return protoimpl.X.MessageOf(m)
}
// Marshaler is implemented by messages that can marshal themselves.
// This interface is used by the following functions: Size, Marshal,
// Buffer.Marshal, and Buffer.EncodeMessage.
//
// Deprecated: Do not implement.
type Marshaler interface {
// Marshal formats the encoded bytes of the message.
// It should be deterministic and emit valid protobuf wire data.
// The caller takes ownership of the returned buffer.
Marshal() ([]byte, error)
}
// Unmarshaler is implemented by messages that can unmarshal themselves.
// This interface is used by the following functions: Unmarshal, UnmarshalMerge,
// Buffer.Unmarshal, Buffer.DecodeMessage, and Buffer.DecodeGroup.
//
// Deprecated: Do not implement.
type Unmarshaler interface {
// Unmarshal parses the encoded bytes of the protobuf wire input.
// The provided buffer is only valid for during method call.
// It should not reset the receiver message.
Unmarshal([]byte) error
}
// Merger is implemented by messages that can merge themselves.
// This interface is used by the following functions: Clone and Merge.
//
// Deprecated: Do not implement.
type Merger interface {
// Merge merges the contents of src into the receiver message.
// It clones all data structures in src such that it aliases no mutable
// memory referenced by src.
Merge(src Message)
}
// RequiredNotSetError is an error type returned when
// marshaling or unmarshaling a message with missing required fields.
type RequiredNotSetError struct {
err error
}
func (e *RequiredNotSetError) Error() string {
if e.err != nil {
return e.err.Error()
}
return "proto: required field not set"
}
func (e *RequiredNotSetError) RequiredNotSet() bool {
return true
}
func checkRequiredNotSet(m protoV2.Message) error {
if err := protoV2.CheckInitialized(m); err != nil {
return &RequiredNotSetError{err: err}
}
return nil
}
// Clone returns a deep copy of src.
func Clone(src Message) Message {
return MessageV1(protoV2.Clone(MessageV2(src)))
}
// Merge merges src into dst, which must be messages of the same type.
//
// Populated scalar fields in src are copied to dst, while populated
// singular messages in src are merged into dst by recursively calling Merge.
// The elements of every list field in src is appended to the corresponded
// list fields in dst. The entries of every map field in src is copied into
// the corresponding map field in dst, possibly replacing existing entries.
// The unknown fields of src are appended to the unknown fields of dst.
func Merge(dst, src Message) {
protoV2.Merge(MessageV2(dst), MessageV2(src))
}
// Equal reports whether two messages are equal.
// If two messages marshal to the same bytes under deterministic serialization,
// then Equal is guaranteed to report true.
//
// Two messages are equal if they are the same protobuf message type,
// have the same set of populated known and extension field values,
// and the same set of unknown fields values.
//
// Scalar values are compared with the equivalent of the == operator in Go,
// except bytes values which are compared using bytes.Equal and
// floating point values which specially treat NaNs as equal.
// Message values are compared by recursively calling Equal.
// Lists are equal if each element value is also equal.
// Maps are equal if they have the same set of keys, where the pair of values
// for each key is also equal.
func Equal(x, y Message) bool {
return protoV2.Equal(MessageV2(x), MessageV2(y))
}
func isMessageSet(md protoreflect.MessageDescriptor) bool {
ms, ok := md.(interface{ IsMessageSet() bool })
return ok && ms.IsMessageSet()
}

323
vendor/github.com/golang/protobuf/proto/registry.go generated vendored Normal file
View file

@ -0,0 +1,323 @@
// Copyright 2019 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
package proto
import (
"bytes"
"compress/gzip"
"fmt"
"io/ioutil"
"reflect"
"strings"
"sync"
"google.golang.org/protobuf/reflect/protoreflect"
"google.golang.org/protobuf/reflect/protoregistry"
"google.golang.org/protobuf/runtime/protoimpl"
)
// filePath is the path to the proto source file.
type filePath = string // e.g., "google/protobuf/descriptor.proto"
// fileDescGZIP is the compressed contents of the encoded FileDescriptorProto.
type fileDescGZIP = []byte
var fileCache sync.Map // map[filePath]fileDescGZIP
// RegisterFile is called from generated code to register the compressed
// FileDescriptorProto with the file path for a proto source file.
//
// Deprecated: Use protoregistry.GlobalFiles.RegisterFile instead.
func RegisterFile(s filePath, d fileDescGZIP) {
// Decompress the descriptor.
zr, err := gzip.NewReader(bytes.NewReader(d))
if err != nil {
panic(fmt.Sprintf("proto: invalid compressed file descriptor: %v", err))
}
b, err := ioutil.ReadAll(zr)
if err != nil {
panic(fmt.Sprintf("proto: invalid compressed file descriptor: %v", err))
}
// Construct a protoreflect.FileDescriptor from the raw descriptor.
// Note that DescBuilder.Build automatically registers the constructed
// file descriptor with the v2 registry.
protoimpl.DescBuilder{RawDescriptor: b}.Build()
// Locally cache the raw descriptor form for the file.
fileCache.Store(s, d)
}
// FileDescriptor returns the compressed FileDescriptorProto given the file path
// for a proto source file. It returns nil if not found.
//
// Deprecated: Use protoregistry.GlobalFiles.FindFileByPath instead.
func FileDescriptor(s filePath) fileDescGZIP {
if v, ok := fileCache.Load(s); ok {
return v.(fileDescGZIP)
}
// Find the descriptor in the v2 registry.
var b []byte
if fd, _ := protoregistry.GlobalFiles.FindFileByPath(s); fd != nil {
if fd, ok := fd.(interface{ ProtoLegacyRawDesc() []byte }); ok {
b = fd.ProtoLegacyRawDesc()
} else {
// TODO: Use protodesc.ToFileDescriptorProto to construct
// a descriptorpb.FileDescriptorProto and marshal it.
// However, doing so causes the proto package to have a dependency
// on descriptorpb, leading to cyclic dependency issues.
}
}
// Locally cache the raw descriptor form for the file.
if len(b) > 0 {
v, _ := fileCache.LoadOrStore(s, protoimpl.X.CompressGZIP(b))
return v.(fileDescGZIP)
}
return nil
}
// enumName is the name of an enum. For historical reasons, the enum name is
// neither the full Go name nor the full protobuf name of the enum.
// The name is the dot-separated combination of just the proto package that the
// enum is declared within followed by the Go type name of the generated enum.
type enumName = string // e.g., "my.proto.package.GoMessage_GoEnum"
// enumsByName maps enum values by name to their numeric counterpart.
type enumsByName = map[string]int32
// enumsByNumber maps enum values by number to their name counterpart.
type enumsByNumber = map[int32]string
var enumCache sync.Map // map[enumName]enumsByName
var numFilesCache sync.Map // map[protoreflect.FullName]int
// RegisterEnum is called from the generated code to register the mapping of
// enum value names to enum numbers for the enum identified by s.
//
// Deprecated: Use protoregistry.GlobalTypes.RegisterEnum instead.
func RegisterEnum(s enumName, _ enumsByNumber, m enumsByName) {
if _, ok := enumCache.Load(s); ok {
panic("proto: duplicate enum registered: " + s)
}
enumCache.Store(s, m)
// This does not forward registration to the v2 registry since this API
// lacks sufficient information to construct a complete v2 enum descriptor.
}
// EnumValueMap returns the mapping from enum value names to enum numbers for
// the enum of the given name. It returns nil if not found.
//
// Deprecated: Use protoregistry.GlobalTypes.FindEnumByName instead.
func EnumValueMap(s enumName) enumsByName {
if v, ok := enumCache.Load(s); ok {
return v.(enumsByName)
}
// Check whether the cache is stale. If the number of files in the current
// package differs, then it means that some enums may have been recently
// registered upstream that we do not know about.
var protoPkg protoreflect.FullName
if i := strings.LastIndexByte(s, '.'); i >= 0 {
protoPkg = protoreflect.FullName(s[:i])
}
v, _ := numFilesCache.Load(protoPkg)
numFiles, _ := v.(int)
if protoregistry.GlobalFiles.NumFilesByPackage(protoPkg) == numFiles {
return nil // cache is up-to-date; was not found earlier
}
// Update the enum cache for all enums declared in the given proto package.
numFiles = 0
protoregistry.GlobalFiles.RangeFilesByPackage(protoPkg, func(fd protoreflect.FileDescriptor) bool {
walkEnums(fd, func(ed protoreflect.EnumDescriptor) {
name := protoimpl.X.LegacyEnumName(ed)
if _, ok := enumCache.Load(name); !ok {
m := make(enumsByName)
evs := ed.Values()
for i := evs.Len() - 1; i >= 0; i-- {
ev := evs.Get(i)
m[string(ev.Name())] = int32(ev.Number())
}
enumCache.LoadOrStore(name, m)
}
})
numFiles++
return true
})
numFilesCache.Store(protoPkg, numFiles)
// Check cache again for enum map.
if v, ok := enumCache.Load(s); ok {
return v.(enumsByName)
}
return nil
}
// walkEnums recursively walks all enums declared in d.
func walkEnums(d interface {
Enums() protoreflect.EnumDescriptors
Messages() protoreflect.MessageDescriptors
}, f func(protoreflect.EnumDescriptor)) {
eds := d.Enums()
for i := eds.Len() - 1; i >= 0; i-- {
f(eds.Get(i))
}
mds := d.Messages()
for i := mds.Len() - 1; i >= 0; i-- {
walkEnums(mds.Get(i), f)
}
}
// messageName is the full name of protobuf message.
type messageName = string
var messageTypeCache sync.Map // map[messageName]reflect.Type
// RegisterType is called from generated code to register the message Go type
// for a message of the given name.
//
// Deprecated: Use protoregistry.GlobalTypes.RegisterMessage instead.
func RegisterType(m Message, s messageName) {
mt := protoimpl.X.LegacyMessageTypeOf(m, protoreflect.FullName(s))
if err := protoregistry.GlobalTypes.RegisterMessage(mt); err != nil {
panic(err)
}
messageTypeCache.Store(s, reflect.TypeOf(m))
}
// RegisterMapType is called from generated code to register the Go map type
// for a protobuf message representing a map entry.
//
// Deprecated: Do not use.
func RegisterMapType(m interface{}, s messageName) {
t := reflect.TypeOf(m)
if t.Kind() != reflect.Map {
panic(fmt.Sprintf("invalid map kind: %v", t))
}
if _, ok := messageTypeCache.Load(s); ok {
panic(fmt.Errorf("proto: duplicate proto message registered: %s", s))
}
messageTypeCache.Store(s, t)
}
// MessageType returns the message type for a named message.
// It returns nil if not found.
//
// Deprecated: Use protoregistry.GlobalTypes.FindMessageByName instead.
func MessageType(s messageName) reflect.Type {
if v, ok := messageTypeCache.Load(s); ok {
return v.(reflect.Type)
}
// Derive the message type from the v2 registry.
var t reflect.Type
if mt, _ := protoregistry.GlobalTypes.FindMessageByName(protoreflect.FullName(s)); mt != nil {
t = messageGoType(mt)
}
// If we could not get a concrete type, it is possible that it is a
// pseudo-message for a map entry.
if t == nil {
d, _ := protoregistry.GlobalFiles.FindDescriptorByName(protoreflect.FullName(s))
if md, _ := d.(protoreflect.MessageDescriptor); md != nil && md.IsMapEntry() {
kt := goTypeForField(md.Fields().ByNumber(1))
vt := goTypeForField(md.Fields().ByNumber(2))
t = reflect.MapOf(kt, vt)
}
}
// Locally cache the message type for the given name.
if t != nil {
v, _ := messageTypeCache.LoadOrStore(s, t)
return v.(reflect.Type)
}
return nil
}
func goTypeForField(fd protoreflect.FieldDescriptor) reflect.Type {
switch k := fd.Kind(); k {
case protoreflect.EnumKind:
if et, _ := protoregistry.GlobalTypes.FindEnumByName(fd.Enum().FullName()); et != nil {
return enumGoType(et)
}
return reflect.TypeOf(protoreflect.EnumNumber(0))
case protoreflect.MessageKind, protoreflect.GroupKind:
if mt, _ := protoregistry.GlobalTypes.FindMessageByName(fd.Message().FullName()); mt != nil {
return messageGoType(mt)
}
return reflect.TypeOf((*protoreflect.Message)(nil)).Elem()
default:
return reflect.TypeOf(fd.Default().Interface())
}
}
func enumGoType(et protoreflect.EnumType) reflect.Type {
return reflect.TypeOf(et.New(0))
}
func messageGoType(mt protoreflect.MessageType) reflect.Type {
return reflect.TypeOf(MessageV1(mt.Zero().Interface()))
}
// MessageName returns the full protobuf name for the given message type.
//
// Deprecated: Use protoreflect.MessageDescriptor.FullName instead.
func MessageName(m Message) messageName {
if m == nil {
return ""
}
if m, ok := m.(interface{ XXX_MessageName() messageName }); ok {
return m.XXX_MessageName()
}
return messageName(protoimpl.X.MessageDescriptorOf(m).FullName())
}
// RegisterExtension is called from the generated code to register
// the extension descriptor.
//
// Deprecated: Use protoregistry.GlobalTypes.RegisterExtension instead.
func RegisterExtension(d *ExtensionDesc) {
if err := protoregistry.GlobalTypes.RegisterExtension(d); err != nil {
panic(err)
}
}
type extensionsByNumber = map[int32]*ExtensionDesc
var extensionCache sync.Map // map[messageName]extensionsByNumber
// RegisteredExtensions returns a map of the registered extensions for the
// provided protobuf message, indexed by the extension field number.
//
// Deprecated: Use protoregistry.GlobalTypes.RangeExtensionsByMessage instead.
func RegisteredExtensions(m Message) extensionsByNumber {
// Check whether the cache is stale. If the number of extensions for
// the given message differs, then it means that some extensions were
// recently registered upstream that we do not know about.
s := MessageName(m)
v, _ := extensionCache.Load(s)
xs, _ := v.(extensionsByNumber)
if protoregistry.GlobalTypes.NumExtensionsByMessage(protoreflect.FullName(s)) == len(xs) {
return xs // cache is up-to-date
}
// Cache is stale, re-compute the extensions map.
xs = make(extensionsByNumber)
protoregistry.GlobalTypes.RangeExtensionsByMessage(protoreflect.FullName(s), func(xt protoreflect.ExtensionType) bool {
if xd, ok := xt.(*ExtensionDesc); ok {
xs[int32(xt.TypeDescriptor().Number())] = xd
} else {
// TODO: This implies that the protoreflect.ExtensionType is a
// custom type not generated by protoc-gen-go. We could try and
// convert the type to an ExtensionDesc.
}
return true
})
extensionCache.Store(s, xs)
return xs
}

2776
vendor/github.com/golang/protobuf/proto/table_marshal.go generated vendored
View file

File diff suppressed because it is too large Load diff

654
vendor/github.com/golang/protobuf/proto/table_merge.go generated vendored
View file

@ -1,654 +0,0 @@
// Go support for Protocol Buffers - Google's data interchange format
//
// Copyright 2016 The Go Authors. All rights reserved.
// https://github.com/golang/protobuf
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
// * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
// * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following disclaimer
// in the documentation and/or other materials provided with the
// distribution.
// * Neither the name of Google Inc. nor the names of its
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
package proto
import (
"fmt"
"reflect"
"strings"
"sync"
"sync/atomic"
)
// Merge merges the src message into dst.
// This assumes that dst and src of the same type and are non-nil.
func (a *InternalMessageInfo) Merge(dst, src Message) {
mi := atomicLoadMergeInfo(&a.merge)
if mi == nil {
mi = getMergeInfo(reflect.TypeOf(dst).Elem())
atomicStoreMergeInfo(&a.merge, mi)
}
mi.merge(toPointer(&dst), toPointer(&src))
}
type mergeInfo struct {
typ reflect.Type
initialized int32 // 0: only typ is valid, 1: everything is valid
lock sync.Mutex
fields []mergeFieldInfo
unrecognized field // Offset of XXX_unrecognized
}
type mergeFieldInfo struct {
field field // Offset of field, guaranteed to be valid
// isPointer reports whether the value in the field is a pointer.
// This is true for the following situations:
// * Pointer to struct
// * Pointer to basic type (proto2 only)
// * Slice (first value in slice header is a pointer)
// * String (first value in string header is a pointer)
isPointer bool
// basicWidth reports the width of the field assuming that it is directly
// embedded in the struct (as is the case for basic types in proto3).
// The possible values are:
// 0: invalid
// 1: bool
// 4: int32, uint32, float32
// 8: int64, uint64, float64
basicWidth int
// Where dst and src are pointers to the types being merged.
merge func(dst, src pointer)
}
var (
mergeInfoMap = map[reflect.Type]*mergeInfo{}
mergeInfoLock sync.Mutex
)
func getMergeInfo(t reflect.Type) *mergeInfo {
mergeInfoLock.Lock()
defer mergeInfoLock.Unlock()
mi := mergeInfoMap[t]
if mi == nil {
mi = &mergeInfo{typ: t}
mergeInfoMap[t] = mi
}
return mi
}
// merge merges src into dst assuming they are both of type *mi.typ.
func (mi *mergeInfo) merge(dst, src pointer) {
if dst.isNil() {
panic("proto: nil destination")
}
if src.isNil() {
return // Nothing to do.
}
if atomic.LoadInt32(&mi.initialized) == 0 {
mi.computeMergeInfo()
}
for _, fi := range mi.fields {
sfp := src.offset(fi.field)
// As an optimization, we can avoid the merge function call cost
// if we know for sure that the source will have no effect
// by checking if it is the zero value.
if unsafeAllowed {
if fi.isPointer && sfp.getPointer().isNil() { // Could be slice or string
continue
}
if fi.basicWidth > 0 {
switch {
case fi.basicWidth == 1 && !*sfp.toBool():
continue
case fi.basicWidth == 4 && *sfp.toUint32() == 0:
continue
case fi.basicWidth == 8 && *sfp.toUint64() == 0:
continue
}
}
}
dfp := dst.offset(fi.field)
fi.merge(dfp, sfp)
}
// TODO: Make this faster?
out := dst.asPointerTo(mi.typ).Elem()
in := src.asPointerTo(mi.typ).Elem()
if emIn, err := extendable(in.Addr().Interface()); err == nil {
emOut, _ := extendable(out.Addr().Interface())
mIn, muIn := emIn.extensionsRead()
if mIn != nil {
mOut := emOut.extensionsWrite()
muIn.Lock()
mergeExtension(mOut, mIn)
muIn.Unlock()
}
}
if mi.unrecognized.IsValid() {
if b := *src.offset(mi.unrecognized).toBytes(); len(b) > 0 {
*dst.offset(mi.unrecognized).toBytes() = append([]byte(nil), b...)
}
}
}
func (mi *mergeInfo) computeMergeInfo() {
mi.lock.Lock()
defer mi.lock.Unlock()
if mi.initialized != 0 {
return
}
t := mi.typ
n := t.NumField()
props := GetProperties(t)
for i := 0; i < n; i++ {
f := t.Field(i)
if strings.HasPrefix(f.Name, "XXX_") {
continue
}
mfi := mergeFieldInfo{field: toField(&f)}
tf := f.Type
// As an optimization, we can avoid the merge function call cost
// if we know for sure that the source will have no effect
// by checking if it is the zero value.
if unsafeAllowed {
switch tf.Kind() {
case reflect.Ptr, reflect.Slice, reflect.String:
// As a special case, we assume slices and strings are pointers
// since we know that the first field in the SliceSlice or
// StringHeader is a data pointer.
mfi.isPointer = true
case reflect.Bool:
mfi.basicWidth = 1
case reflect.Int32, reflect.Uint32, reflect.Float32:
mfi.basicWidth = 4
case reflect.Int64, reflect.Uint64, reflect.Float64:
mfi.basicWidth = 8
}
}
// Unwrap tf to get at its most basic type.
var isPointer, isSlice bool
if tf.Kind() == reflect.Slice && tf.Elem().Kind() != reflect.Uint8 {
isSlice = true
tf = tf.Elem()
}
if tf.Kind() == reflect.Ptr {
isPointer = true
tf = tf.Elem()
}
if isPointer && isSlice && tf.Kind() != reflect.Struct {
panic("both pointer and slice for basic type in " + tf.Name())
}
switch tf.Kind() {
case reflect.Int32:
switch {
case isSlice: // E.g., []int32
mfi.merge = func(dst, src pointer) {
// NOTE: toInt32Slice is not defined (see pointer_reflect.go).
/*
sfsp := src.toInt32Slice()
if *sfsp != nil {
dfsp := dst.toInt32Slice()
*dfsp = append(*dfsp, *sfsp...)
if *dfsp == nil {
*dfsp = []int64{}
}
}
*/
sfs := src.getInt32Slice()
if sfs != nil {
dfs := dst.getInt32Slice()
dfs = append(dfs, sfs...)
if dfs == nil {
dfs = []int32{}
}
dst.setInt32Slice(dfs)
}
}
case isPointer: // E.g., *int32
mfi.merge = func(dst, src pointer) {
// NOTE: toInt32Ptr is not defined (see pointer_reflect.go).
/*
sfpp := src.toInt32Ptr()
if *sfpp != nil {
dfpp := dst.toInt32Ptr()
if *dfpp == nil {
*dfpp = Int32(**sfpp)
} else {
**dfpp = **sfpp
}
}
*/
sfp := src.getInt32Ptr()
if sfp != nil {
dfp := dst.getInt32Ptr()
if dfp == nil {
dst.setInt32Ptr(*sfp)
} else {
*dfp = *sfp
}
}
}
default: // E.g., int32
mfi.merge = func(dst, src pointer) {
if v := *src.toInt32(); v != 0 {
*dst.toInt32() = v
}
}
}
case reflect.Int64:
switch {
case isSlice: // E.g., []int64
mfi.merge = func(dst, src pointer) {
sfsp := src.toInt64Slice()
if *sfsp != nil {
dfsp := dst.toInt64Slice()
*dfsp = append(*dfsp, *sfsp...)
if *dfsp == nil {
*dfsp = []int64{}
}
}
}
case isPointer: // E.g., *int64
mfi.merge = func(dst, src pointer) {
sfpp := src.toInt64Ptr()
if *sfpp != nil {
dfpp := dst.toInt64Ptr()
if *dfpp == nil {
*dfpp = Int64(**sfpp)
} else {
**dfpp = **sfpp
}
}
}
default: // E.g., int64
mfi.merge = func(dst, src pointer) {
if v := *src.toInt64(); v != 0 {
*dst.toInt64() = v
}
}
}
case reflect.Uint32:
switch {
case isSlice: // E.g., []uint32
mfi.merge = func(dst, src pointer) {
sfsp := src.toUint32Slice()
if *sfsp != nil {
dfsp := dst.toUint32Slice()
*dfsp = append(*dfsp, *sfsp...)
if *dfsp == nil {
*dfsp = []uint32{}
}
}
}
case isPointer: // E.g., *uint32
mfi.merge = func(dst, src pointer) {
sfpp := src.toUint32Ptr()
if *sfpp != nil {
dfpp := dst.toUint32Ptr()
if *dfpp == nil {
*dfpp = Uint32(**sfpp)
} else {
**dfpp = **sfpp
}
}
}
default: // E.g., uint32
mfi.merge = func(dst, src pointer) {
if v := *src.toUint32(); v != 0 {
*dst.toUint32() = v
}
}
}
case reflect.Uint64:
switch {
case isSlice: // E.g., []uint64
mfi.merge = func(dst, src pointer) {
sfsp := src.toUint64Slice()
if *sfsp != nil {
dfsp := dst.toUint64Slice()
*dfsp = append(*dfsp, *sfsp...)
if *dfsp == nil {
*dfsp = []uint64{}
}
}
}
case isPointer: // E.g., *uint64
mfi.merge = func(dst, src pointer) {
sfpp := src.toUint64Ptr()
if *sfpp != nil {
dfpp := dst.toUint64Ptr()
if *dfpp == nil {
*dfpp = Uint64(**sfpp)
} else {
**dfpp = **sfpp
}
}
}
default: // E.g., uint64
mfi.merge = func(dst, src pointer) {
if v := *src.toUint64(); v != 0 {
*dst.toUint64() = v
}
}
}
case reflect.Float32:
switch {
case isSlice: // E.g., []float32
mfi.merge = func(dst, src pointer) {
sfsp := src.toFloat32Slice()
if *sfsp != nil {
dfsp := dst.toFloat32Slice()
*dfsp = append(*dfsp, *sfsp...)
if *dfsp == nil {
*dfsp = []float32{}
}
}
}
case isPointer: // E.g., *float32
mfi.merge = func(dst, src pointer) {
sfpp := src.toFloat32Ptr()
if *sfpp != nil {
dfpp := dst.toFloat32Ptr()
if *dfpp == nil {
*dfpp = Float32(**sfpp)
} else {
**dfpp = **sfpp
}
}
}
default: // E.g., float32
mfi.merge = func(dst, src pointer) {
if v := *src.toFloat32(); v != 0 {
*dst.toFloat32() = v
}
}
}
case reflect.Float64:
switch {
case isSlice: // E.g., []float64
mfi.merge = func(dst, src pointer) {
sfsp := src.toFloat64Slice()
if *sfsp != nil {
dfsp := dst.toFloat64Slice()
*dfsp = append(*dfsp, *sfsp...)
if *dfsp == nil {
*dfsp = []float64{}
}
}
}
case isPointer: // E.g., *float64
mfi.merge = func(dst, src pointer) {
sfpp := src.toFloat64Ptr()
if *sfpp != nil {
dfpp := dst.toFloat64Ptr()
if *dfpp == nil {
*dfpp = Float64(**sfpp)
} else {
**dfpp = **sfpp
}
}
}
default: // E.g., float64
mfi.merge = func(dst, src pointer) {
if v := *src.toFloat64(); v != 0 {
*dst.toFloat64() = v
}
}
}
case reflect.Bool:
switch {
case isSlice: // E.g., []bool
mfi.merge = func(dst, src pointer) {
sfsp := src.toBoolSlice()
if *sfsp != nil {
dfsp := dst.toBoolSlice()
*dfsp = append(*dfsp, *sfsp...)
if *dfsp == nil {
*dfsp = []bool{}
}
}
}
case isPointer: // E.g., *bool
mfi.merge = func(dst, src pointer) {
sfpp := src.toBoolPtr()
if *sfpp != nil {
dfpp := dst.toBoolPtr()
if *dfpp == nil {
*dfpp = Bool(**sfpp)
} else {
**dfpp = **sfpp
}
}
}
default: // E.g., bool
mfi.merge = func(dst, src pointer) {
if v := *src.toBool(); v {
*dst.toBool() = v
}
}
}
case reflect.String:
switch {
case isSlice: // E.g., []string
mfi.merge = func(dst, src pointer) {
sfsp := src.toStringSlice()
if *sfsp != nil {
dfsp := dst.toStringSlice()
*dfsp = append(*dfsp, *sfsp...)
if *dfsp == nil {
*dfsp = []string{}
}
}
}
case isPointer: // E.g., *string
mfi.merge = func(dst, src pointer) {
sfpp := src.toStringPtr()
if *sfpp != nil {
dfpp := dst.toStringPtr()
if *dfpp == nil {
*dfpp = String(**sfpp)
} else {
**dfpp = **sfpp
}
}
}
default: // E.g., string
mfi.merge = func(dst, src pointer) {
if v := *src.toString(); v != "" {
*dst.toString() = v
}
}
}
case reflect.Slice:
isProto3 := props.Prop[i].proto3
switch {
case isPointer:
panic("bad pointer in byte slice case in " + tf.Name())
case tf.Elem().Kind() != reflect.Uint8:
panic("bad element kind in byte slice case in " + tf.Name())
case isSlice: // E.g., [][]byte
mfi.merge = func(dst, src pointer) {
sbsp := src.toBytesSlice()
if *sbsp != nil {
dbsp := dst.toBytesSlice()
for _, sb := range *sbsp {
if sb == nil {
*dbsp = append(*dbsp, nil)
} else {
*dbsp = append(*dbsp, append([]byte{}, sb...))
}
}
if *dbsp == nil {
*dbsp = [][]byte{}
}
}
}
default: // E.g., []byte
mfi.merge = func(dst, src pointer) {
sbp := src.toBytes()
if *sbp != nil {
dbp := dst.toBytes()
if !isProto3 || len(*sbp) > 0 {
*dbp = append([]byte{}, *sbp...)
}
}
}
}
case reflect.Struct:
switch {
case !isPointer:
panic(fmt.Sprintf("message field %s without pointer", tf))
case isSlice: // E.g., []*pb.T
mi := getMergeInfo(tf)
mfi.merge = func(dst, src pointer) {
sps := src.getPointerSlice()
if sps != nil {
dps := dst.getPointerSlice()
for _, sp := range sps {
var dp pointer
if !sp.isNil() {
dp = valToPointer(reflect.New(tf))
mi.merge(dp, sp)
}
dps = append(dps, dp)
}
if dps == nil {
dps = []pointer{}
}
dst.setPointerSlice(dps)
}
}
default: // E.g., *pb.T
mi := getMergeInfo(tf)
mfi.merge = func(dst, src pointer) {
sp := src.getPointer()
if !sp.isNil() {
dp := dst.getPointer()
if dp.isNil() {
dp = valToPointer(reflect.New(tf))
dst.setPointer(dp)
}
mi.merge(dp, sp)
}
}
}
case reflect.Map:
switch {
case isPointer || isSlice:
panic("bad pointer or slice in map case in " + tf.Name())
default: // E.g., map[K]V
mfi.merge = func(dst, src pointer) {
sm := src.asPointerTo(tf).Elem()
if sm.Len() == 0 {
return
}
dm := dst.asPointerTo(tf).Elem()
if dm.IsNil() {
dm.Set(reflect.MakeMap(tf))
}
switch tf.Elem().Kind() {
case reflect.Ptr: // Proto struct (e.g., *T)
for _, key := range sm.MapKeys() {
val := sm.MapIndex(key)
val = reflect.ValueOf(Clone(val.Interface().(Message)))
dm.SetMapIndex(key, val)
}
case reflect.Slice: // E.g. Bytes type (e.g., []byte)
for _, key := range sm.MapKeys() {
val := sm.MapIndex(key)
val = reflect.ValueOf(append([]byte{}, val.Bytes()...))
dm.SetMapIndex(key, val)
}
default: // Basic type (e.g., string)
for _, key := range sm.MapKeys() {
val := sm.MapIndex(key)
dm.SetMapIndex(key, val)
}
}
}
}
case reflect.Interface:
// Must be oneof field.
switch {
case isPointer || isSlice:
panic("bad pointer or slice in interface case in " + tf.Name())
default: // E.g., interface{}
// TODO: Make this faster?
mfi.merge = func(dst, src pointer) {
su := src.asPointerTo(tf).Elem()
if !su.IsNil() {
du := dst.asPointerTo(tf).Elem()
typ := su.Elem().Type()
if du.IsNil() || du.Elem().Type() != typ {
du.Set(reflect.New(typ.Elem())) // Initialize interface if empty
}
sv := su.Elem().Elem().Field(0)
if sv.Kind() == reflect.Ptr && sv.IsNil() {
return
}
dv := du.Elem().Elem().Field(0)
if dv.Kind() == reflect.Ptr && dv.IsNil() {
dv.Set(reflect.New(sv.Type().Elem())) // Initialize proto message if empty
}
switch sv.Type().Kind() {
case reflect.Ptr: // Proto struct (e.g., *T)
Merge(dv.Interface().(Message), sv.Interface().(Message))
case reflect.Slice: // E.g. Bytes type (e.g., []byte)
dv.Set(reflect.ValueOf(append([]byte{}, sv.Bytes()...)))
default: // Basic type (e.g., string)
dv.Set(sv)
}
}
}
}
default:
panic(fmt.Sprintf("merger not found for type:%s", tf))
}
mi.fields = append(mi.fields, mfi)
}
mi.unrecognized = invalidField
if f, ok := t.FieldByName("XXX_unrecognized"); ok {
if f.Type != reflect.TypeOf([]byte{}) {
panic("expected XXX_unrecognized to be of type []byte")
}
mi.unrecognized = toField(&f)
}
atomic.StoreInt32(&mi.initialized, 1)
}

2053
vendor/github.com/golang/protobuf/proto/table_unmarshal.go generated vendored
View file

File diff suppressed because it is too large Load diff

845
vendor/github.com/golang/protobuf/proto/text.go generated vendored
View file

@ -1,845 +0,0 @@
// Go support for Protocol Buffers - Google's data interchange format
//
// Copyright 2010 The Go Authors. All rights reserved.
// https://github.com/golang/protobuf
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
// * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
// * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following disclaimer
// in the documentation and/or other materials provided with the
// distribution.
// * Neither the name of Google Inc. nor the names of its
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
package proto
// Functions for writing the text protocol buffer format.
import (
"bufio"
"bytes"
"encoding"
"errors"
"fmt"
"io"
"log"
"math"
"reflect"
"sort"
"strings"
)
var (
newline = []byte("\n")
spaces = []byte(" ")
endBraceNewline = []byte("}\n")
backslashN = []byte{'\\', 'n'}
backslashR = []byte{'\\', 'r'}
backslashT = []byte{'\\', 't'}
backslashDQ = []byte{'\\', '"'}
backslashBS = []byte{'\\', '\\'}
posInf = []byte("inf")
negInf = []byte("-inf")
nan = []byte("nan")
)
type writer interface {
io.Writer
WriteByte(byte) error
}
// textWriter is an io.Writer that tracks its indentation level.
type textWriter struct {
ind int
complete bool // if the current position is a complete line
compact bool // whether to write out as a one-liner
w writer
}
func (w *textWriter) WriteString(s string) (n int, err error) {
if !strings.Contains(s, "\n") {
if !w.compact && w.complete {
w.writeIndent()
}
w.complete = false
return io.WriteString(w.w, s)
}
// WriteString is typically called without newlines, so this
// codepath and its copy are rare. We copy to avoid
// duplicating all of Write's logic here.
return w.Write([]byte(s))
}
func (w *textWriter) Write(p []byte) (n int, err error) {
newlines := bytes.Count(p, newline)
if newlines == 0 {
if !w.compact && w.complete {
w.writeIndent()
}
n, err = w.w.Write(p)
w.complete = false
return n, err
}
frags := bytes.SplitN(p, newline, newlines+1)
if w.compact {
for i, frag := range frags {
if i > 0 {
if err := w.w.WriteByte(' '); err != nil {
return n, err
}
n++
}
nn, err := w.w.Write(frag)
n += nn
if err != nil {
return n, err
}
}
return n, nil
}
for i, frag := range frags {
if w.complete {
w.writeIndent()
}
nn, err := w.w.Write(frag)
n += nn
if err != nil {
return n, err
}
if i+1 < len(frags) {
if err := w.w.WriteByte('\n'); err != nil {
return n, err
}
n++
}
}
w.complete = len(frags[len(frags)-1]) == 0
return n, nil
}
func (w *textWriter) WriteByte(c byte) error {
if w.compact && c == '\n' {
c = ' '
}
if !w.compact && w.complete {
w.writeIndent()
}
err := w.w.WriteByte(c)
w.complete = c == '\n'
return err
}
func (w *textWriter) indent() { w.ind++ }
func (w *textWriter) unindent() {
if w.ind == 0 {
log.Print("proto: textWriter unindented too far")
return
}
w.ind--
}
func writeName(w *textWriter, props *Properties) error {
if _, err := w.WriteString(props.OrigName); err != nil {
return err
}
if props.Wire != "group" {
return w.WriteByte(':')
}
return nil
}
func requiresQuotes(u string) bool {
// When type URL contains any characters except [0-9A-Za-z./\-]*, it must be quoted.
for _, ch := range u {
switch {
case ch == '.' || ch == '/' || ch == '_':
continue
case '0' <= ch && ch <= '9':
continue
case 'A' <= ch && ch <= 'Z':
continue
case 'a' <= ch && ch <= 'z':
continue
default:
return true
}
}
return false
}
// isAny reports whether sv is a google.protobuf.Any message
func isAny(sv reflect.Value) bool {
type wkt interface {
XXX_WellKnownType() string
}
t, ok := sv.Addr().Interface().(wkt)
return ok && t.XXX_WellKnownType() == "Any"
}
// writeProto3Any writes an expanded google.protobuf.Any message.
//
// It returns (false, nil) if sv value can't be unmarshaled (e.g. because
// required messages are not linked in).
//
// It returns (true, error) when sv was written in expanded format or an error
// was encountered.
func (tm *TextMarshaler) writeProto3Any(w *textWriter, sv reflect.Value) (bool, error) {
turl := sv.FieldByName("TypeUrl")
val := sv.FieldByName("Value")
if !turl.IsValid() || !val.IsValid() {
return true, errors.New("proto: invalid google.protobuf.Any message")
}
b, ok := val.Interface().([]byte)
if !ok {
return true, errors.New("proto: invalid google.protobuf.Any message")
}
parts := strings.Split(turl.String(), "/")
mt := MessageType(parts[len(parts)-1])
if mt == nil {
return false, nil
}
m := reflect.New(mt.Elem())
if err := Unmarshal(b, m.Interface().(Message)); err != nil {
return false, nil
}
w.Write([]byte("["))
u := turl.String()
if requiresQuotes(u) {
writeString(w, u)
} else {
w.Write([]byte(u))
}
if w.compact {
w.Write([]byte("]:<"))
} else {
w.Write([]byte("]: <\n"))
w.ind++
}
if err := tm.writeStruct(w, m.Elem()); err != nil {
return true, err
}
if w.compact {
w.Write([]byte("> "))
} else {
w.ind--
w.Write([]byte(">\n"))
}
return true, nil
}
func (tm *TextMarshaler) writeStruct(w *textWriter, sv reflect.Value) error {
if tm.ExpandAny && isAny(sv) {
if canExpand, err := tm.writeProto3Any(w, sv); canExpand {
return err
}
}
st := sv.Type()
sprops := GetProperties(st)
for i := 0; i < sv.NumField(); i++ {
fv := sv.Field(i)
props := sprops.Prop[i]
name := st.Field(i).Name
if name == "XXX_NoUnkeyedLiteral" {
continue
}
if strings.HasPrefix(name, "XXX_") {
// There are two XXX_ fields:
// XXX_unrecognized []byte
// XXX_extensions map[int32]proto.Extension
// The first is handled here;
// the second is handled at the bottom of this function.
if name == "XXX_unrecognized" && !fv.IsNil() {
if err := writeUnknownStruct(w, fv.Interface().([]byte)); err != nil {
return err
}
}
continue
}
if fv.Kind() == reflect.Ptr && fv.IsNil() {
// Field not filled in. This could be an optional field or
// a required field that wasn't filled in. Either way, there
// isn't anything we can show for it.
continue
}
if fv.Kind() == reflect.Slice && fv.IsNil() {
// Repeated field that is empty, or a bytes field that is unused.
continue
}
if props.Repeated && fv.Kind() == reflect.Slice {
// Repeated field.
for j := 0; j < fv.Len(); j++ {
if err := writeName(w, props); err != nil {
return err
}
if !w.compact {
if err := w.WriteByte(' '); err != nil {
return err
}
}
v := fv.Index(j)
if v.Kind() == reflect.Ptr && v.IsNil() {
// A nil message in a repeated field is not valid,
// but we can handle that more gracefully than panicking.
if _, err := w.Write([]byte("<nil>\n")); err != nil {
return err
}
continue
}
if err := tm.writeAny(w, v, props); err != nil {
return err
}
if err := w.WriteByte('\n'); err != nil {
return err
}
}
continue
}
if fv.Kind() == reflect.Map {
// Map fields are rendered as a repeated struct with key/value fields.
keys := fv.MapKeys()
sort.Sort(mapKeys(keys))
for _, key := range keys {
val := fv.MapIndex(key)
if err := writeName(w, props); err != nil {
return err
}
if !w.compact {
if err := w.WriteByte(' '); err != nil {
return err
}
}
// open struct
if err := w.WriteByte('<'); err != nil {
return err
}
if !w.compact {
if err := w.WriteByte('\n'); err != nil {
return err
}
}
w.indent()
// key
if _, err := w.WriteString("key:"); err != nil {
return err
}
if !w.compact {
if err := w.WriteByte(' '); err != nil {
return err
}
}
if err := tm.writeAny(w, key, props.MapKeyProp); err != nil {
return err
}
if err := w.WriteByte('\n'); err != nil {
return err
}
// nil values aren't legal, but we can avoid panicking because of them.
if val.Kind() != reflect.Ptr || !val.IsNil() {
// value
if _, err := w.WriteString("value:"); err != nil {
return err
}
if !w.compact {
if err := w.WriteByte(' '); err != nil {
return err
}
}
if err := tm.writeAny(w, val, props.MapValProp); err != nil {
return err
}
if err := w.WriteByte('\n'); err != nil {
return err
}
}
// close struct
w.unindent()
if err := w.WriteByte('>'); err != nil {
return err
}
if err := w.WriteByte('\n'); err != nil {
return err
}
}
continue
}
if props.proto3 && fv.Kind() == reflect.Slice && fv.Len() == 0 {
// empty bytes field
continue
}
if fv.Kind() != reflect.Ptr && fv.Kind() != reflect.Slice {
// proto3 non-repeated scalar field; skip if zero value
if isProto3Zero(fv) {
continue
}
}
if fv.Kind() == reflect.Interface {
// Check if it is a oneof.
if st.Field(i).Tag.Get("protobuf_oneof") != "" {
// fv is nil, or holds a pointer to generated struct.
// That generated struct has exactly one field,
// which has a protobuf struct tag.
if fv.IsNil() {
continue
}
inner := fv.Elem().Elem() // interface -> *T -> T
tag := inner.Type().Field(0).Tag.Get("protobuf")
props = new(Properties) // Overwrite the outer props var, but not its pointee.
props.Parse(tag)
// Write the value in the oneof, not the oneof itself.
fv = inner.Field(0)
// Special case to cope with malformed messages gracefully:
// If the value in the oneof is a nil pointer, don't panic
// in writeAny.
if fv.Kind() == reflect.Ptr && fv.IsNil() {
// Use errors.New so writeAny won't render quotes.
msg := errors.New("/* nil */")
fv = reflect.ValueOf(&msg).Elem()
}
}
}
if err := writeName(w, props); err != nil {
return err
}
if !w.compact {
if err := w.WriteByte(' '); err != nil {
return err
}
}
// Enums have a String method, so writeAny will work fine.
if err := tm.writeAny(w, fv, props); err != nil {
return err
}
if err := w.WriteByte('\n'); err != nil {
return err
}
}
// Extensions (the XXX_extensions field).
pv := sv.Addr()
if _, err := extendable(pv.Interface()); err == nil {
if err := tm.writeExtensions(w, pv); err != nil {
return err
}
}
return nil
}
var textMarshalerType = reflect.TypeOf((*encoding.TextMarshaler)(nil)).Elem()
// writeAny writes an arbitrary field.
func (tm *TextMarshaler) writeAny(w *textWriter, v reflect.Value, props *Properties) error {
v = reflect.Indirect(v)
// Floats have special cases.
if v.Kind() == reflect.Float32 || v.Kind() == reflect.Float64 {
x := v.Float()
var b []byte
switch {
case math.IsInf(x, 1):
b = posInf
case math.IsInf(x, -1):
b = negInf
case math.IsNaN(x):
b = nan
}
if b != nil {
_, err := w.Write(b)
return err
}
// Other values are handled below.
}
// We don't attempt to serialise every possible value type; only those
// that can occur in protocol buffers.
switch v.Kind() {
case reflect.Slice:
// Should only be a []byte; repeated fields are handled in writeStruct.
if err := writeString(w, string(v.Bytes())); err != nil {
return err
}
case reflect.String:
if err := writeString(w, v.String()); err != nil {
return err
}
case reflect.Struct:
// Required/optional group/message.
var bra, ket byte = '<', '>'
if props != nil && props.Wire == "group" {
bra, ket = '{', '}'
}
if err := w.WriteByte(bra); err != nil {
return err
}
if !w.compact {
if err := w.WriteByte('\n'); err != nil {
return err
}
}
w.indent()
if v.CanAddr() {
// Calling v.Interface on a struct causes the reflect package to
// copy the entire struct. This is racy with the new Marshaler
// since we atomically update the XXX_sizecache.
//
// Thus, we retrieve a pointer to the struct if possible to avoid
// a race since v.Interface on the pointer doesn't copy the struct.
//
// If v is not addressable, then we are not worried about a race
// since it implies that the binary Marshaler cannot possibly be
// mutating this value.
v = v.Addr()
}
if v.Type().Implements(textMarshalerType) {
text, err := v.Interface().(encoding.TextMarshaler).MarshalText()
if err != nil {
return err
}
if _, err = w.Write(text); err != nil {
return err
}
} else {
if v.Kind() == reflect.Ptr {
v = v.Elem()
}
if err := tm.writeStruct(w, v); err != nil {
return err
}
}
w.unindent()
if err := w.WriteByte(ket); err != nil {
return err
}
default:
_, err := fmt.Fprint(w, v.Interface())
return err
}
return nil
}
// equivalent to C's isprint.
func isprint(c byte) bool {
return c >= 0x20 && c < 0x7f
}
// writeString writes a string in the protocol buffer text format.
// It is similar to strconv.Quote except we don't use Go escape sequences,
// we treat the string as a byte sequence, and we use octal escapes.
// These differences are to maintain interoperability with the other
// languages' implementations of the text format.
func writeString(w *textWriter, s string) error {
// use WriteByte here to get any needed indent
if err := w.WriteByte('"'); err != nil {
return err
}
// Loop over the bytes, not the runes.
for i := 0; i < len(s); i++ {
var err error
// Divergence from C++: we don't escape apostrophes.
// There's no need to escape them, and the C++ parser
// copes with a naked apostrophe.
switch c := s[i]; c {
case '\n':
_, err = w.w.Write(backslashN)
case '\r':
_, err = w.w.Write(backslashR)
case '\t':
_, err = w.w.Write(backslashT)
case '"':
_, err = w.w.Write(backslashDQ)
case '\\':
_, err = w.w.Write(backslashBS)
default:
if isprint(c) {
err = w.w.WriteByte(c)
} else {
_, err = fmt.Fprintf(w.w, "\\%03o", c)
}
}
if err != nil {
return err
}
}
return w.WriteByte('"')
}
func writeUnknownStruct(w *textWriter, data []byte) (err error) {
if !w.compact {
if _, err := fmt.Fprintf(w, "/* %d unknown bytes */\n", len(data)); err != nil {
return err
}
}
b := NewBuffer(data)
for b.index < len(b.buf) {
x, err := b.DecodeVarint()
if err != nil {
_, err := fmt.Fprintf(w, "/* %v */\n", err)
return err
}
wire, tag := x&7, x>>3
if wire == WireEndGroup {
w.unindent()
if _, err := w.Write(endBraceNewline); err != nil {
return err
}
continue
}
if _, err := fmt.Fprint(w, tag); err != nil {
return err
}
if wire != WireStartGroup {
if err := w.WriteByte(':'); err != nil {
return err
}
}
if !w.compact || wire == WireStartGroup {
if err := w.WriteByte(' '); err != nil {
return err
}
}
switch wire {
case WireBytes:
buf, e := b.DecodeRawBytes(false)
if e == nil {
_, err = fmt.Fprintf(w, "%q", buf)
} else {
_, err = fmt.Fprintf(w, "/* %v */", e)
}
case WireFixed32:
x, err = b.DecodeFixed32()
err = writeUnknownInt(w, x, err)
case WireFixed64:
x, err = b.DecodeFixed64()
err = writeUnknownInt(w, x, err)
case WireStartGroup:
err = w.WriteByte('{')
w.indent()
case WireVarint:
x, err = b.DecodeVarint()
err = writeUnknownInt(w, x, err)
default:
_, err = fmt.Fprintf(w, "/* unknown wire type %d */", wire)
}
if err != nil {
return err
}
if err = w.WriteByte('\n'); err != nil {
return err
}
}
return nil
}
func writeUnknownInt(w *textWriter, x uint64, err error) error {
if err == nil {
_, err = fmt.Fprint(w, x)
} else {
_, err = fmt.Fprintf(w, "/* %v */", err)
}
return err
}
type int32Slice []int32
func (s int32Slice) Len() int { return len(s) }
func (s int32Slice) Less(i, j int) bool { return s[i] < s[j] }
func (s int32Slice) Swap(i, j int) { s[i], s[j] = s[j], s[i] }
// writeExtensions writes all the extensions in pv.
// pv is assumed to be a pointer to a protocol message struct that is extendable.
func (tm *TextMarshaler) writeExtensions(w *textWriter, pv reflect.Value) error {
emap := extensionMaps[pv.Type().Elem()]
ep, _ := extendable(pv.Interface())
// Order the extensions by ID.
// This isn't strictly necessary, but it will give us
// canonical output, which will also make testing easier.
m, mu := ep.extensionsRead()
if m == nil {
return nil
}
mu.Lock()
ids := make([]int32, 0, len(m))
for id := range m {
ids = append(ids, id)
}
sort.Sort(int32Slice(ids))
mu.Unlock()
for _, extNum := range ids {
ext := m[extNum]
var desc *ExtensionDesc
if emap != nil {
desc = emap[extNum]
}
if desc == nil {
// Unknown extension.
if err := writeUnknownStruct(w, ext.enc); err != nil {
return err
}
continue
}
pb, err := GetExtension(ep, desc)
if err != nil {
return fmt.Errorf("failed getting extension: %v", err)
}
// Repeated extensions will appear as a slice.
if !desc.repeated() {
if err := tm.writeExtension(w, desc.Name, pb); err != nil {
return err
}
} else {
v := reflect.ValueOf(pb)
for i := 0; i < v.Len(); i++ {
if err := tm.writeExtension(w, desc.Name, v.Index(i).Interface()); err != nil {
return err
}
}
}
}
return nil
}
func (tm *TextMarshaler) writeExtension(w *textWriter, name string, pb interface{}) error {
if _, err := fmt.Fprintf(w, "[%s]:", name); err != nil {
return err
}
if !w.compact {
if err := w.WriteByte(' '); err != nil {
return err
}
}
if err := tm.writeAny(w, reflect.ValueOf(pb), nil); err != nil {
return err
}
if err := w.WriteByte('\n'); err != nil {
return err
}
return nil
}
func (w *textWriter) writeIndent() {
if !w.complete {
return
}
remain := w.ind * 2
for remain > 0 {
n := remain
if n > len(spaces) {
n = len(spaces)
}
w.w.Write(spaces[:n])
remain -= n
}
w.complete = false
}
// TextMarshaler is a configurable text format marshaler.
type TextMarshaler struct {
Compact bool // use compact text format (one line).
ExpandAny bool // expand google.protobuf.Any messages of known types
}
// Marshal writes a given protocol buffer in text format.
// The only errors returned are from w.
func (tm *TextMarshaler) Marshal(w io.Writer, pb Message) error {
val := reflect.ValueOf(pb)
if pb == nil || val.IsNil() {
w.Write([]byte("<nil>"))
return nil
}
var bw *bufio.Writer
ww, ok := w.(writer)
if !ok {
bw = bufio.NewWriter(w)
ww = bw
}
aw := &textWriter{
w: ww,
complete: true,
compact: tm.Compact,
}
if etm, ok := pb.(encoding.TextMarshaler); ok {
text, err := etm.MarshalText()
if err != nil {
return err
}
if _, err = aw.Write(text); err != nil {
return err
}
if bw != nil {
return bw.Flush()
}
return nil
}
// Dereference the received pointer so we don't have outer < and >.
v := reflect.Indirect(val)
if err := tm.writeStruct(aw, v); err != nil {
return err
}
if bw != nil {
return bw.Flush()
}
return nil
}
// Text is the same as Marshal, but returns the string directly.
func (tm *TextMarshaler) Text(pb Message) string {
var buf bytes.Buffer
tm.Marshal(&buf, pb)
return buf.String()
}
var (
defaultTextMarshaler = TextMarshaler{}
compactTextMarshaler = TextMarshaler{Compact: true}
)
// TODO: consider removing some of the Marshal functions below.
// MarshalText writes a given protocol buffer in text format.
// The only errors returned are from w.
func MarshalText(w io.Writer, pb Message) error { return defaultTextMarshaler.Marshal(w, pb) }
// MarshalTextString is the same as MarshalText, but returns the string directly.
func MarshalTextString(pb Message) string { return defaultTextMarshaler.Text(pb) }
// CompactText writes a given protocol buffer in compact text format (one line).
func CompactText(w io.Writer, pb Message) error { return compactTextMarshaler.Marshal(w, pb) }
// CompactTextString is the same as CompactText, but returns the string directly.
func CompactTextString(pb Message) string { return compactTextMarshaler.Text(pb) }

801
vendor/github.com/golang/protobuf/proto/text_decode.go generated vendored Normal file
View file

@ -0,0 +1,801 @@
// Copyright 2010 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
package proto
import (
"encoding"
"errors"
"fmt"
"reflect"
"strconv"
"strings"
"unicode/utf8"
"google.golang.org/protobuf/encoding/prototext"
protoV2 "google.golang.org/protobuf/proto"
"google.golang.org/protobuf/reflect/protoreflect"
"google.golang.org/protobuf/reflect/protoregistry"
)
const wrapTextUnmarshalV2 = false
// ParseError is returned by UnmarshalText.
type ParseError struct {
Message string
// Deprecated: Do not use.
Line, Offset int
}
func (e *ParseError) Error() string {
if wrapTextUnmarshalV2 {
return e.Message
}
if e.Line == 1 {
return fmt.Sprintf("line 1.%d: %v", e.Offset, e.Message)
}
return fmt.Sprintf("line %d: %v", e.Line, e.Message)
}
// UnmarshalText parses a proto text formatted string into m.
func UnmarshalText(s string, m Message) error {
if u, ok := m.(encoding.TextUnmarshaler); ok {
return u.UnmarshalText([]byte(s))
}
m.Reset()
mi := MessageV2(m)
if wrapTextUnmarshalV2 {
err := prototext.UnmarshalOptions{
AllowPartial: true,
}.Unmarshal([]byte(s), mi)
if err != nil {
return &ParseError{Message: err.Error()}
}
return checkRequiredNotSet(mi)
} else {
if err := newTextParser(s).unmarshalMessage(mi.ProtoReflect(), ""); err != nil {
return err
}
return checkRequiredNotSet(mi)
}
}
type textParser struct {
s string // remaining input
done bool // whether the parsing is finished (success or error)
backed bool // whether back() was called
offset, line int
cur token
}
type token struct {
value string
err *ParseError
line int // line number
offset int // byte number from start of input, not start of line
unquoted string // the unquoted version of value, if it was a quoted string
}
func newTextParser(s string) *textParser {
p := new(textParser)
p.s = s
p.line = 1
p.cur.line = 1
return p
}
func (p *textParser) unmarshalMessage(m protoreflect.Message, terminator string) (err error) {
md := m.Descriptor()
fds := md.Fields()
// A struct is a sequence of "name: value", terminated by one of
// '>' or '}', or the end of the input. A name may also be
// "[extension]" or "[type/url]".
//
// The whole struct can also be an expanded Any message, like:
// [type/url] < ... struct contents ... >
seen := make(map[protoreflect.FieldNumber]bool)
for {
tok := p.next()
if tok.err != nil {
return tok.err
}
if tok.value == terminator {
break
}
if tok.value == "[" {
if err := p.unmarshalExtensionOrAny(m, seen); err != nil {
return err
}
continue
}
// This is a normal, non-extension field.
name := protoreflect.Name(tok.value)
fd := fds.ByName(name)
switch {
case fd == nil:
gd := fds.ByName(protoreflect.Name(strings.ToLower(string(name))))
if gd != nil && gd.Kind() == protoreflect.GroupKind && gd.Message().Name() == name {
fd = gd
}
case fd.Kind() == protoreflect.GroupKind && fd.Message().Name() != name:
fd = nil
case fd.IsWeak() && fd.Message().IsPlaceholder():
fd = nil
}
if fd == nil {
typeName := string(md.FullName())
if m, ok := m.Interface().(Message); ok {
t := reflect.TypeOf(m)
if t.Kind() == reflect.Ptr {
typeName = t.Elem().String()
}
}
return p.errorf("unknown field name %q in %v", name, typeName)
}
if od := fd.ContainingOneof(); od != nil && m.WhichOneof(od) != nil {
return p.errorf("field '%s' would overwrite already parsed oneof '%s'", name, od.Name())
}
if fd.Cardinality() != protoreflect.Repeated && seen[fd.Number()] {
return p.errorf("non-repeated field %q was repeated", fd.Name())
}
seen[fd.Number()] = true
// Consume any colon.
if err := p.checkForColon(fd); err != nil {
return err
}
// Parse into the field.
v := m.Get(fd)
if !m.Has(fd) && (fd.IsList() || fd.IsMap() || fd.Message() != nil) {
v = m.Mutable(fd)
}
if v, err = p.unmarshalValue(v, fd); err != nil {
return err
}
m.Set(fd, v)
if err := p.consumeOptionalSeparator(); err != nil {
return err
}
}
return nil
}
func (p *textParser) unmarshalExtensionOrAny(m protoreflect.Message, seen map[protoreflect.FieldNumber]bool) error {
name, err := p.consumeExtensionOrAnyName()
if err != nil {
return err
}
// If it contains a slash, it's an Any type URL.
if slashIdx := strings.LastIndex(name, "/"); slashIdx >= 0 {
tok := p.next()
if tok.err != nil {
return tok.err
}
// consume an optional colon
if tok.value == ":" {
tok = p.next()
if tok.err != nil {
return tok.err
}
}
var terminator string
switch tok.value {
case "<":
terminator = ">"
case "{":
terminator = "}"
default:
return p.errorf("expected '{' or '<', found %q", tok.value)
}
mt, err := protoregistry.GlobalTypes.FindMessageByURL(name)
if err != nil {
return p.errorf("unrecognized message %q in google.protobuf.Any", name[slashIdx+len("/"):])
}
m2 := mt.New()
if err := p.unmarshalMessage(m2, terminator); err != nil {
return err
}
b, err := protoV2.Marshal(m2.Interface())
if err != nil {
return p.errorf("failed to marshal message of type %q: %v", name[slashIdx+len("/"):], err)
}
urlFD := m.Descriptor().Fields().ByName("type_url")
valFD := m.Descriptor().Fields().ByName("value")
if seen[urlFD.Number()] {
return p.errorf("Any message unpacked multiple times, or %q already set", urlFD.Name())
}
if seen[valFD.Number()] {
return p.errorf("Any message unpacked multiple times, or %q already set", valFD.Name())
}
m.Set(urlFD, protoreflect.ValueOfString(name))
m.Set(valFD, protoreflect.ValueOfBytes(b))
seen[urlFD.Number()] = true
seen[valFD.Number()] = true
return nil
}
xname := protoreflect.FullName(name)
xt, _ := protoregistry.GlobalTypes.FindExtensionByName(xname)
if xt == nil && isMessageSet(m.Descriptor()) {
xt, _ = protoregistry.GlobalTypes.FindExtensionByName(xname.Append("message_set_extension"))
}
if xt == nil {
return p.errorf("unrecognized extension %q", name)
}
fd := xt.TypeDescriptor()
if fd.ContainingMessage().FullName() != m.Descriptor().FullName() {
return p.errorf("extension field %q does not extend message %q", name, m.Descriptor().FullName())
}
if err := p.checkForColon(fd); err != nil {
return err
}
v := m.Get(fd)
if !m.Has(fd) && (fd.IsList() || fd.IsMap() || fd.Message() != nil) {
v = m.Mutable(fd)
}
v, err = p.unmarshalValue(v, fd)
if err != nil {
return err
}
m.Set(fd, v)
return p.consumeOptionalSeparator()
}
func (p *textParser) unmarshalValue(v protoreflect.Value, fd protoreflect.FieldDescriptor) (protoreflect.Value, error) {
tok := p.next()
if tok.err != nil {
return v, tok.err
}
if tok.value == "" {
return v, p.errorf("unexpected EOF")
}
switch {
case fd.IsList():
lv := v.List()
var err error
if tok.value == "[" {
// Repeated field with list notation, like [1,2,3].
for {
vv := lv.NewElement()
vv, err = p.unmarshalSingularValue(vv, fd)
if err != nil {
return v, err
}
lv.Append(vv)
tok := p.next()
if tok.err != nil {
return v, tok.err
}
if tok.value == "]" {
break
}
if tok.value != "," {
return v, p.errorf("Expected ']' or ',' found %q", tok.value)
}
}
return v, nil
}
// One value of the repeated field.
p.back()
vv := lv.NewElement()
vv, err = p.unmarshalSingularValue(vv, fd)
if err != nil {
return v, err
}
lv.Append(vv)
return v, nil
case fd.IsMap():
// The map entry should be this sequence of tokens:
// < key : KEY value : VALUE >
// However, implementations may omit key or value, and technically
// we should support them in any order.
var terminator string
switch tok.value {
case "<":
terminator = ">"
case "{":
terminator = "}"
default:
return v, p.errorf("expected '{' or '<', found %q", tok.value)
}
keyFD := fd.MapKey()
valFD := fd.MapValue()
mv := v.Map()
kv := keyFD.Default()
vv := mv.NewValue()
for {
tok := p.next()
if tok.err != nil {
return v, tok.err
}
if tok.value == terminator {
break
}
var err error
switch tok.value {
case "key":
if err := p.consumeToken(":"); err != nil {
return v, err
}
if kv, err = p.unmarshalSingularValue(kv, keyFD); err != nil {
return v, err
}
if err := p.consumeOptionalSeparator(); err != nil {
return v, err
}
case "value":
if err := p.checkForColon(valFD); err != nil {
return v, err
}
if vv, err = p.unmarshalSingularValue(vv, valFD); err != nil {
return v, err
}
if err := p.consumeOptionalSeparator(); err != nil {
return v, err
}
default:
p.back()
return v, p.errorf(`expected "key", "value", or %q, found %q`, terminator, tok.value)
}
}
mv.Set(kv.MapKey(), vv)
return v, nil
default:
p.back()
return p.unmarshalSingularValue(v, fd)
}
}
func (p *textParser) unmarshalSingularValue(v protoreflect.Value, fd protoreflect.FieldDescriptor) (protoreflect.Value, error) {
tok := p.next()
if tok.err != nil {
return v, tok.err
}
if tok.value == "" {
return v, p.errorf("unexpected EOF")
}
switch fd.Kind() {
case protoreflect.BoolKind:
switch tok.value {
case "true", "1", "t", "True":
return protoreflect.ValueOfBool(true), nil
case "false", "0", "f", "False":
return protoreflect.ValueOfBool(false), nil
}
case protoreflect.Int32Kind, protoreflect.Sint32Kind, protoreflect.Sfixed32Kind:
if x, err := strconv.ParseInt(tok.value, 0, 32); err == nil {
return protoreflect.ValueOfInt32(int32(x)), nil
}
// The C++ parser accepts large positive hex numbers that uses
// two's complement arithmetic to represent negative numbers.
// This feature is here for backwards compatibility with C++.
if strings.HasPrefix(tok.value, "0x") {
if x, err := strconv.ParseUint(tok.value, 0, 32); err == nil {
return protoreflect.ValueOfInt32(int32(-(int64(^x) + 1))), nil
}
}
case protoreflect.Int64Kind, protoreflect.Sint64Kind, protoreflect.Sfixed64Kind:
if x, err := strconv.ParseInt(tok.value, 0, 64); err == nil {
return protoreflect.ValueOfInt64(int64(x)), nil
}
// The C++ parser accepts large positive hex numbers that uses
// two's complement arithmetic to represent negative numbers.
// This feature is here for backwards compatibility with C++.
if strings.HasPrefix(tok.value, "0x") {
if x, err := strconv.ParseUint(tok.value, 0, 64); err == nil {
return protoreflect.ValueOfInt64(int64(-(int64(^x) + 1))), nil
}
}
case protoreflect.Uint32Kind, protoreflect.Fixed32Kind:
if x, err := strconv.ParseUint(tok.value, 0, 32); err == nil {
return protoreflect.ValueOfUint32(uint32(x)), nil
}
case protoreflect.Uint64Kind, protoreflect.Fixed64Kind:
if x, err := strconv.ParseUint(tok.value, 0, 64); err == nil {
return protoreflect.ValueOfUint64(uint64(x)), nil
}
case protoreflect.FloatKind:
// Ignore 'f' for compatibility with output generated by C++,
// but don't remove 'f' when the value is "-inf" or "inf".
v := tok.value
if strings.HasSuffix(v, "f") && v != "-inf" && v != "inf" {
v = v[:len(v)-len("f")]
}
if x, err := strconv.ParseFloat(v, 32); err == nil {
return protoreflect.ValueOfFloat32(float32(x)), nil
}
case protoreflect.DoubleKind:
// Ignore 'f' for compatibility with output generated by C++,
// but don't remove 'f' when the value is "-inf" or "inf".
v := tok.value
if strings.HasSuffix(v, "f") && v != "-inf" && v != "inf" {
v = v[:len(v)-len("f")]
}
if x, err := strconv.ParseFloat(v, 64); err == nil {
return protoreflect.ValueOfFloat64(float64(x)), nil
}
case protoreflect.StringKind:
if isQuote(tok.value[0]) {
return protoreflect.ValueOfString(tok.unquoted), nil
}
case protoreflect.BytesKind:
if isQuote(tok.value[0]) {
return protoreflect.ValueOfBytes([]byte(tok.unquoted)), nil
}
case protoreflect.EnumKind:
if x, err := strconv.ParseInt(tok.value, 0, 32); err == nil {
return protoreflect.ValueOfEnum(protoreflect.EnumNumber(x)), nil
}
vd := fd.Enum().Values().ByName(protoreflect.Name(tok.value))
if vd != nil {
return protoreflect.ValueOfEnum(vd.Number()), nil
}
case protoreflect.MessageKind, protoreflect.GroupKind:
var terminator string
switch tok.value {
case "{":
terminator = "}"
case "<":
terminator = ">"
default:
return v, p.errorf("expected '{' or '<', found %q", tok.value)
}
err := p.unmarshalMessage(v.Message(), terminator)
return v, err
default:
panic(fmt.Sprintf("invalid kind %v", fd.Kind()))
}
return v, p.errorf("invalid %v: %v", fd.Kind(), tok.value)
}
// Consume a ':' from the input stream (if the next token is a colon),
// returning an error if a colon is needed but not present.
func (p *textParser) checkForColon(fd protoreflect.FieldDescriptor) *ParseError {
tok := p.next()
if tok.err != nil {
return tok.err
}
if tok.value != ":" {
if fd.Message() == nil {
return p.errorf("expected ':', found %q", tok.value)
}
p.back()
}
return nil
}
// consumeExtensionOrAnyName consumes an extension name or an Any type URL and
// the following ']'. It returns the name or URL consumed.
func (p *textParser) consumeExtensionOrAnyName() (string, error) {
tok := p.next()
if tok.err != nil {
return "", tok.err
}
// If extension name or type url is quoted, it's a single token.
if len(tok.value) > 2 && isQuote(tok.value[0]) && tok.value[len(tok.value)-1] == tok.value[0] {
name, err := unquoteC(tok.value[1:len(tok.value)-1], rune(tok.value[0]))
if err != nil {
return "", err
}
return name, p.consumeToken("]")
}
// Consume everything up to "]"
var parts []string
for tok.value != "]" {
parts = append(parts, tok.value)
tok = p.next()
if tok.err != nil {
return "", p.errorf("unrecognized type_url or extension name: %s", tok.err)
}
if p.done && tok.value != "]" {
return "", p.errorf("unclosed type_url or extension name")
}
}
return strings.Join(parts, ""), nil
}
// consumeOptionalSeparator consumes an optional semicolon or comma.
// It is used in unmarshalMessage to provide backward compatibility.
func (p *textParser) consumeOptionalSeparator() error {
tok := p.next()
if tok.err != nil {
return tok.err
}
if tok.value != ";" && tok.value != "," {
p.back()
}
return nil
}
func (p *textParser) errorf(format string, a ...interface{}) *ParseError {
pe := &ParseError{fmt.Sprintf(format, a...), p.cur.line, p.cur.offset}
p.cur.err = pe
p.done = true
return pe
}
func (p *textParser) skipWhitespace() {
i := 0
for i < len(p.s) && (isWhitespace(p.s[i]) || p.s[i] == '#') {
if p.s[i] == '#' {
// comment; skip to end of line or input
for i < len(p.s) && p.s[i] != '\n' {
i++
}
if i == len(p.s) {
break
}
}
if p.s[i] == '\n' {
p.line++
}
i++
}
p.offset += i
p.s = p.s[i:len(p.s)]
if len(p.s) == 0 {
p.done = true
}
}
func (p *textParser) advance() {
// Skip whitespace
p.skipWhitespace()
if p.done {
return
}
// Start of non-whitespace
p.cur.err = nil
p.cur.offset, p.cur.line = p.offset, p.line
p.cur.unquoted = ""
switch p.s[0] {
case '<', '>', '{', '}', ':', '[', ']', ';', ',', '/':
// Single symbol
p.cur.value, p.s = p.s[0:1], p.s[1:len(p.s)]
case '"', '\'':
// Quoted string
i := 1
for i < len(p.s) && p.s[i] != p.s[0] && p.s[i] != '\n' {
if p.s[i] == '\\' && i+1 < len(p.s) {
// skip escaped char
i++
}
i++
}
if i >= len(p.s) || p.s[i] != p.s[0] {
p.errorf("unmatched quote")
return
}
unq, err := unquoteC(p.s[1:i], rune(p.s[0]))
if err != nil {
p.errorf("invalid quoted string %s: %v", p.s[0:i+1], err)
return
}
p.cur.value, p.s = p.s[0:i+1], p.s[i+1:len(p.s)]
p.cur.unquoted = unq
default:
i := 0
for i < len(p.s) && isIdentOrNumberChar(p.s[i]) {
i++
}
if i == 0 {
p.errorf("unexpected byte %#x", p.s[0])
return
}
p.cur.value, p.s = p.s[0:i], p.s[i:len(p.s)]
}
p.offset += len(p.cur.value)
}
// Back off the parser by one token. Can only be done between calls to next().
// It makes the next advance() a no-op.
func (p *textParser) back() { p.backed = true }
// Advances the parser and returns the new current token.
func (p *textParser) next() *token {
if p.backed || p.done {
p.backed = false
return &p.cur
}
p.advance()
if p.done {
p.cur.value = ""
} else if len(p.cur.value) > 0 && isQuote(p.cur.value[0]) {
// Look for multiple quoted strings separated by whitespace,
// and concatenate them.
cat := p.cur
for {
p.skipWhitespace()
if p.done || !isQuote(p.s[0]) {
break
}
p.advance()
if p.cur.err != nil {
return &p.cur
}
cat.value += " " + p.cur.value
cat.unquoted += p.cur.unquoted
}
p.done = false // parser may have seen EOF, but we want to return cat
p.cur = cat
}
return &p.cur
}
func (p *textParser) consumeToken(s string) error {
tok := p.next()
if tok.err != nil {
return tok.err
}
if tok.value != s {
p.back()
return p.errorf("expected %q, found %q", s, tok.value)
}
return nil
}
var errBadUTF8 = errors.New("proto: bad UTF-8")
func unquoteC(s string, quote rune) (string, error) {
// This is based on C++'s tokenizer.cc.
// Despite its name, this is *not* parsing C syntax.
// For instance, "\0" is an invalid quoted string.
// Avoid allocation in trivial cases.
simple := true
for _, r := range s {
if r == '\\' || r == quote {
simple = false
break
}
}
if simple {
return s, nil
}
buf := make([]byte, 0, 3*len(s)/2)
for len(s) > 0 {
r, n := utf8.DecodeRuneInString(s)
if r == utf8.RuneError && n == 1 {
return "", errBadUTF8
}
s = s[n:]
if r != '\\' {
if r < utf8.RuneSelf {
buf = append(buf, byte(r))
} else {
buf = append(buf, string(r)...)
}
continue
}
ch, tail, err := unescape(s)
if err != nil {
return "", err
}
buf = append(buf, ch...)
s = tail
}
return string(buf), nil
}
func unescape(s string) (ch string, tail string, err error) {
r, n := utf8.DecodeRuneInString(s)
if r == utf8.RuneError && n == 1 {
return "", "", errBadUTF8
}
s = s[n:]
switch r {
case 'a':
return "\a", s, nil
case 'b':
return "\b", s, nil
case 'f':
return "\f", s, nil
case 'n':
return "\n", s, nil
case 'r':
return "\r", s, nil
case 't':
return "\t", s, nil
case 'v':
return "\v", s, nil
case '?':
return "?", s, nil // trigraph workaround
case '\'', '"', '\\':
return string(r), s, nil
case '0', '1', '2', '3', '4', '5', '6', '7':
if len(s) < 2 {
return "", "", fmt.Errorf(`\%c requires 2 following digits`, r)
}
ss := string(r) + s[:2]
s = s[2:]
i, err := strconv.ParseUint(ss, 8, 8)
if err != nil {
return "", "", fmt.Errorf(`\%s contains non-octal digits`, ss)
}
return string([]byte{byte(i)}), s, nil
case 'x', 'X', 'u', 'U':
var n int
switch r {
case 'x', 'X':
n = 2
case 'u':
n = 4
case 'U':
n = 8
}
if len(s) < n {
return "", "", fmt.Errorf(`\%c requires %d following digits`, r, n)
}
ss := s[:n]
s = s[n:]
i, err := strconv.ParseUint(ss, 16, 64)
if err != nil {
return "", "", fmt.Errorf(`\%c%s contains non-hexadecimal digits`, r, ss)
}
if r == 'x' || r == 'X' {
return string([]byte{byte(i)}), s, nil
}
if i > utf8.MaxRune {
return "", "", fmt.Errorf(`\%c%s is not a valid Unicode code point`, r, ss)
}
return string(i), s, nil
}
return "", "", fmt.Errorf(`unknown escape \%c`, r)
}
func isIdentOrNumberChar(c byte) bool {
switch {
case 'A' <= c && c <= 'Z', 'a' <= c && c <= 'z':
return true
case '0' <= c && c <= '9':
return true
}
switch c {
case '-', '+', '.', '_':
return true
}
return false
}
func isWhitespace(c byte) bool {
switch c {
case ' ', '\t', '\n', '\r':
return true
}
return false
}
func isQuote(c byte) bool {
switch c {
case '"', '\'':
return true
}
return false
}

560
vendor/github.com/golang/protobuf/proto/text_encode.go generated vendored Normal file
View file

@ -0,0 +1,560 @@
// Copyright 2010 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
package proto
import (
"bytes"
"encoding"
"fmt"
"io"
"math"
"sort"
"strings"
"google.golang.org/protobuf/encoding/prototext"
"google.golang.org/protobuf/encoding/protowire"
"google.golang.org/protobuf/proto"
"google.golang.org/protobuf/reflect/protoreflect"
"google.golang.org/protobuf/reflect/protoregistry"
)
const wrapTextMarshalV2 = false
// TextMarshaler is a configurable text format marshaler.
type TextMarshaler struct {
Compact bool // use compact text format (one line)
ExpandAny bool // expand google.protobuf.Any messages of known types
}
// Marshal writes the proto text format of m to w.
func (tm *TextMarshaler) Marshal(w io.Writer, m Message) error {
b, err := tm.marshal(m)
if len(b) > 0 {
if _, err := w.Write(b); err != nil {
return err
}
}
return err
}
// Text returns a proto text formatted string of m.
func (tm *TextMarshaler) Text(m Message) string {
b, _ := tm.marshal(m)
return string(b)
}
func (tm *TextMarshaler) marshal(m Message) ([]byte, error) {
mr := MessageReflect(m)
if mr == nil || !mr.IsValid() {
return []byte("<nil>"), nil
}
if wrapTextMarshalV2 {
if m, ok := m.(encoding.TextMarshaler); ok {
return m.MarshalText()
}
opts := prototext.MarshalOptions{
AllowPartial: true,
EmitUnknown: true,
}
if !tm.Compact {
opts.Indent = " "
}
if !tm.ExpandAny {
opts.Resolver = (*protoregistry.Types)(nil)
}
return opts.Marshal(mr.Interface())
} else {
w := &textWriter{
compact: tm.Compact,
expandAny: tm.ExpandAny,
complete: true,
}
if m, ok := m.(encoding.TextMarshaler); ok {
b, err := m.MarshalText()
if err != nil {
return nil, err
}
w.Write(b)
return w.buf, nil
}
err := w.writeMessage(mr)
return w.buf, err
}
}
var (
defaultTextMarshaler = TextMarshaler{}
compactTextMarshaler = TextMarshaler{Compact: true}
)
// MarshalText writes the proto text format of m to w.
func MarshalText(w io.Writer, m Message) error { return defaultTextMarshaler.Marshal(w, m) }
// MarshalTextString returns a proto text formatted string of m.
func MarshalTextString(m Message) string { return defaultTextMarshaler.Text(m) }
// CompactText writes the compact proto text format of m to w.
func CompactText(w io.Writer, m Message) error { return compactTextMarshaler.Marshal(w, m) }
// CompactTextString returns a compact proto text formatted string of m.
func CompactTextString(m Message) string { return compactTextMarshaler.Text(m) }
var (
newline = []byte("\n")
endBraceNewline = []byte("}\n")
posInf = []byte("inf")
negInf = []byte("-inf")
nan = []byte("nan")
)
// textWriter is an io.Writer that tracks its indentation level.
type textWriter struct {
compact bool // same as TextMarshaler.Compact
expandAny bool // same as TextMarshaler.ExpandAny
complete bool // whether the current position is a complete line
indent int // indentation level; never negative
buf []byte
}
func (w *textWriter) Write(p []byte) (n int, _ error) {
newlines := bytes.Count(p, newline)
if newlines == 0 {
if !w.compact && w.complete {
w.writeIndent()
}
w.buf = append(w.buf, p...)
w.complete = false
return len(p), nil
}
frags := bytes.SplitN(p, newline, newlines+1)
if w.compact {
for i, frag := range frags {
if i > 0 {
w.buf = append(w.buf, ' ')
n++
}
w.buf = append(w.buf, frag...)
n += len(frag)
}
return n, nil
}
for i, frag := range frags {
if w.complete {
w.writeIndent()
}
w.buf = append(w.buf, frag...)
n += len(frag)
if i+1 < len(frags) {
w.buf = append(w.buf, '\n')
n++
}
}
w.complete = len(frags[len(frags)-1]) == 0
return n, nil
}
func (w *textWriter) WriteByte(c byte) error {
if w.compact && c == '\n' {
c = ' '
}
if !w.compact && w.complete {
w.writeIndent()
}
w.buf = append(w.buf, c)
w.complete = c == '\n'
return nil
}
func (w *textWriter) writeName(fd protoreflect.FieldDescriptor) {
if !w.compact && w.complete {
w.writeIndent()
}
w.complete = false
if fd.Kind() != protoreflect.GroupKind {
w.buf = append(w.buf, fd.Name()...)
w.WriteByte(':')
} else {
// Use message type name for group field name.
w.buf = append(w.buf, fd.Message().Name()...)
}
if !w.compact {
w.WriteByte(' ')
}
}
func requiresQuotes(u string) bool {
// When type URL contains any characters except [0-9A-Za-z./\-]*, it must be quoted.
for _, ch := range u {
switch {
case ch == '.' || ch == '/' || ch == '_':
continue
case '0' <= ch && ch <= '9':
continue
case 'A' <= ch && ch <= 'Z':
continue
case 'a' <= ch && ch <= 'z':
continue
default:
return true
}
}
return false
}
// writeProto3Any writes an expanded google.protobuf.Any message.
//
// It returns (false, nil) if sv value can't be unmarshaled (e.g. because
// required messages are not linked in).
//
// It returns (true, error) when sv was written in expanded format or an error
// was encountered.
func (w *textWriter) writeProto3Any(m protoreflect.Message) (bool, error) {
md := m.Descriptor()
fdURL := md.Fields().ByName("type_url")
fdVal := md.Fields().ByName("value")
url := m.Get(fdURL).String()
mt, err := protoregistry.GlobalTypes.FindMessageByURL(url)
if err != nil {
return false, nil
}
b := m.Get(fdVal).Bytes()
m2 := mt.New()
if err := proto.Unmarshal(b, m2.Interface()); err != nil {
return false, nil
}
w.Write([]byte("["))
if requiresQuotes(url) {
w.writeQuotedString(url)
} else {
w.Write([]byte(url))
}
if w.compact {
w.Write([]byte("]:<"))
} else {
w.Write([]byte("]: <\n"))
w.indent++
}
if err := w.writeMessage(m2); err != nil {
return true, err
}
if w.compact {
w.Write([]byte("> "))
} else {
w.indent--
w.Write([]byte(">\n"))
}
return true, nil
}
func (w *textWriter) writeMessage(m protoreflect.Message) error {
md := m.Descriptor()
if w.expandAny && md.FullName() == "google.protobuf.Any" {
if canExpand, err := w.writeProto3Any(m); canExpand {
return err
}
}
fds := md.Fields()
for i := 0; i < fds.Len(); {
fd := fds.Get(i)
if od := fd.ContainingOneof(); od != nil {
fd = m.WhichOneof(od)
i += od.Fields().Len()
} else {
i++
}
if fd == nil || !m.Has(fd) {
continue
}
switch {
case fd.IsList():
lv := m.Get(fd).List()
for j := 0; j < lv.Len(); j++ {
w.writeName(fd)
v := lv.Get(j)
if err := w.writeSingularValue(v, fd); err != nil {
return err
}
w.WriteByte('\n')
}
case fd.IsMap():
kfd := fd.MapKey()
vfd := fd.MapValue()
mv := m.Get(fd).Map()
type entry struct{ key, val protoreflect.Value }
var entries []entry
mv.Range(func(k protoreflect.MapKey, v protoreflect.Value) bool {
entries = append(entries, entry{k.Value(), v})
return true
})
sort.Slice(entries, func(i, j int) bool {
switch kfd.Kind() {
case protoreflect.BoolKind:
return !entries[i].key.Bool() && entries[j].key.Bool()
case protoreflect.Int32Kind, protoreflect.Sint32Kind, protoreflect.Sfixed32Kind, protoreflect.Int64Kind, protoreflect.Sint64Kind, protoreflect.Sfixed64Kind:
return entries[i].key.Int() < entries[j].key.Int()
case protoreflect.Uint32Kind, protoreflect.Fixed32Kind, protoreflect.Uint64Kind, protoreflect.Fixed64Kind:
return entries[i].key.Uint() < entries[j].key.Uint()
case protoreflect.StringKind:
return entries[i].key.String() < entries[j].key.String()
default:
panic("invalid kind")
}
})
for _, entry := range entries {
w.writeName(fd)
w.WriteByte('<')
if !w.compact {
w.WriteByte('\n')
}
w.indent++
w.writeName(kfd)
if err := w.writeSingularValue(entry.key, kfd); err != nil {
return err
}
w.WriteByte('\n')
w.writeName(vfd)
if err := w.writeSingularValue(entry.val, vfd); err != nil {
return err
}
w.WriteByte('\n')
w.indent--
w.WriteByte('>')
w.WriteByte('\n')
}
default:
w.writeName(fd)
if err := w.writeSingularValue(m.Get(fd), fd); err != nil {
return err
}
w.WriteByte('\n')
}
}
if b := m.GetUnknown(); len(b) > 0 {
w.writeUnknownFields(b)
}
return w.writeExtensions(m)
}
func (w *textWriter) writeSingularValue(v protoreflect.Value, fd protoreflect.FieldDescriptor) error {
switch fd.Kind() {
case protoreflect.FloatKind, protoreflect.DoubleKind:
switch vf := v.Float(); {
case math.IsInf(vf, +1):
w.Write(posInf)
case math.IsInf(vf, -1):
w.Write(negInf)
case math.IsNaN(vf):
w.Write(nan)
default:
fmt.Fprint(w, v.Interface())
}
case protoreflect.StringKind:
// NOTE: This does not validate UTF-8 for historical reasons.
w.writeQuotedString(string(v.String()))
case protoreflect.BytesKind:
w.writeQuotedString(string(v.Bytes()))
case protoreflect.MessageKind, protoreflect.GroupKind:
var bra, ket byte = '<', '>'
if fd.Kind() == protoreflect.GroupKind {
bra, ket = '{', '}'
}
w.WriteByte(bra)
if !w.compact {
w.WriteByte('\n')
}
w.indent++
m := v.Message()
if m2, ok := m.Interface().(encoding.TextMarshaler); ok {
b, err := m2.MarshalText()
if err != nil {
return err
}
w.Write(b)
} else {
w.writeMessage(m)
}
w.indent--
w.WriteByte(ket)
case protoreflect.EnumKind:
if ev := fd.Enum().Values().ByNumber(v.Enum()); ev != nil {
fmt.Fprint(w, ev.Name())
} else {
fmt.Fprint(w, v.Enum())
}
default:
fmt.Fprint(w, v.Interface())
}
return nil
}
// writeQuotedString writes a quoted string in the protocol buffer text format.
func (w *textWriter) writeQuotedString(s string) {
w.WriteByte('"')
for i := 0; i < len(s); i++ {
switch c := s[i]; c {
case '\n':
w.buf = append(w.buf, `\n`...)
case '\r':
w.buf = append(w.buf, `\r`...)
case '\t':
w.buf = append(w.buf, `\t`...)
case '"':
w.buf = append(w.buf, `\"`...)
case '\\':
w.buf = append(w.buf, `\\`...)
default:
if isPrint := c >= 0x20 && c < 0x7f; isPrint {
w.buf = append(w.buf, c)
} else {
w.buf = append(w.buf, fmt.Sprintf(`\%03o`, c)...)
}
}
}
w.WriteByte('"')
}
func (w *textWriter) writeUnknownFields(b []byte) {
if !w.compact {
fmt.Fprintf(w, "/* %d unknown bytes */\n", len(b))
}
for len(b) > 0 {
num, wtyp, n := protowire.ConsumeTag(b)
if n < 0 {
return
}
b = b[n:]
if wtyp == protowire.EndGroupType {
w.indent--
w.Write(endBraceNewline)
continue
}
fmt.Fprint(w, num)
if wtyp != protowire.StartGroupType {
w.WriteByte(':')
}
if !w.compact || wtyp == protowire.StartGroupType {
w.WriteByte(' ')
}
switch wtyp {
case protowire.VarintType:
v, n := protowire.ConsumeVarint(b)
if n < 0 {
return
}
b = b[n:]
fmt.Fprint(w, v)
case protowire.Fixed32Type:
v, n := protowire.ConsumeFixed32(b)
if n < 0 {
return
}
b = b[n:]
fmt.Fprint(w, v)
case protowire.Fixed64Type:
v, n := protowire.ConsumeFixed64(b)
if n < 0 {
return
}
b = b[n:]
fmt.Fprint(w, v)
case protowire.BytesType:
v, n := protowire.ConsumeBytes(b)
if n < 0 {
return
}
b = b[n:]
fmt.Fprintf(w, "%q", v)
case protowire.StartGroupType:
w.WriteByte('{')
w.indent++
default:
fmt.Fprintf(w, "/* unknown wire type %d */", wtyp)
}
w.WriteByte('\n')
}
}
// writeExtensions writes all the extensions in m.
func (w *textWriter) writeExtensions(m protoreflect.Message) error {
md := m.Descriptor()
if md.ExtensionRanges().Len() == 0 {
return nil
}
type ext struct {
desc protoreflect.FieldDescriptor
val protoreflect.Value
}
var exts []ext
m.Range(func(fd protoreflect.FieldDescriptor, v protoreflect.Value) bool {
if fd.IsExtension() {
exts = append(exts, ext{fd, v})
}
return true
})
sort.Slice(exts, func(i, j int) bool {
return exts[i].desc.Number() < exts[j].desc.Number()
})
for _, ext := range exts {
// For message set, use the name of the message as the extension name.
name := string(ext.desc.FullName())
if isMessageSet(ext.desc.ContainingMessage()) {
name = strings.TrimSuffix(name, ".message_set_extension")
}
if !ext.desc.IsList() {
if err := w.writeSingularExtension(name, ext.val, ext.desc); err != nil {
return err
}
} else {
lv := ext.val.List()
for i := 0; i < lv.Len(); i++ {
if err := w.writeSingularExtension(name, lv.Get(i), ext.desc); err != nil {
return err
}
}
}
}
return nil
}
func (w *textWriter) writeSingularExtension(name string, v protoreflect.Value, fd protoreflect.FieldDescriptor) error {
fmt.Fprintf(w, "[%s]:", name)
if !w.compact {
w.WriteByte(' ')
}
if err := w.writeSingularValue(v, fd); err != nil {
return err
}
w.WriteByte('\n')
return nil
}
func (w *textWriter) writeIndent() {
if !w.complete {
return
}
for i := 0; i < w.indent*2; i++ {
w.buf = append(w.buf, ' ')
}
w.complete = false
}

880
vendor/github.com/golang/protobuf/proto/text_parser.go generated vendored
View file

@ -1,880 +0,0 @@
// Go support for Protocol Buffers - Google's data interchange format
//
// Copyright 2010 The Go Authors. All rights reserved.
// https://github.com/golang/protobuf
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
// * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
// * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following disclaimer
// in the documentation and/or other materials provided with the
// distribution.
// * Neither the name of Google Inc. nor the names of its
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
package proto
// Functions for parsing the Text protocol buffer format.
// TODO: message sets.
import (
"encoding"
"errors"
"fmt"
"reflect"
"strconv"
"strings"
"unicode/utf8"
)
// Error string emitted when deserializing Any and fields are already set
const anyRepeatedlyUnpacked = "Any message unpacked multiple times, or %q already set"
type ParseError struct {
Message string
Line int // 1-based line number
Offset int // 0-based byte offset from start of input
}
func (p *ParseError) Error() string {
if p.Line == 1 {
// show offset only for first line
return fmt.Sprintf("line 1.%d: %v", p.Offset, p.Message)
}
return fmt.Sprintf("line %d: %v", p.Line, p.Message)
}
type token struct {
value string
err *ParseError
line int // line number
offset int // byte number from start of input, not start of line
unquoted string // the unquoted version of value, if it was a quoted string
}
func (t *token) String() string {
if t.err == nil {
return fmt.Sprintf("%q (line=%d, offset=%d)", t.value, t.line, t.offset)
}
return fmt.Sprintf("parse error: %v", t.err)
}
type textParser struct {
s string // remaining input
done bool // whether the parsing is finished (success or error)
backed bool // whether back() was called
offset, line int
cur token
}
func newTextParser(s string) *textParser {
p := new(textParser)
p.s = s
p.line = 1
p.cur.line = 1
return p
}
func (p *textParser) errorf(format string, a ...interface{}) *ParseError {
pe := &ParseError{fmt.Sprintf(format, a...), p.cur.line, p.cur.offset}
p.cur.err = pe
p.done = true
return pe
}
// Numbers and identifiers are matched by [-+._A-Za-z0-9]
func isIdentOrNumberChar(c byte) bool {
switch {
case 'A' <= c && c <= 'Z', 'a' <= c && c <= 'z':
return true
case '0' <= c && c <= '9':
return true
}
switch c {
case '-', '+', '.', '_':
return true
}
return false
}
func isWhitespace(c byte) bool {
switch c {
case ' ', '\t', '\n', '\r':
return true
}
return false
}
func isQuote(c byte) bool {
switch c {
case '"', '\'':
return true
}
return false
}
func (p *textParser) skipWhitespace() {
i := 0
for i < len(p.s) && (isWhitespace(p.s[i]) || p.s[i] == '#') {
if p.s[i] == '#' {
// comment; skip to end of line or input
for i < len(p.s) && p.s[i] != '\n' {
i++
}
if i == len(p.s) {
break
}
}
if p.s[i] == '\n' {
p.line++
}
i++
}
p.offset += i
p.s = p.s[i:len(p.s)]
if len(p.s) == 0 {
p.done = true
}
}
func (p *textParser) advance() {
// Skip whitespace
p.skipWhitespace()
if p.done {
return
}
// Start of non-whitespace
p.cur.err = nil
p.cur.offset, p.cur.line = p.offset, p.line
p.cur.unquoted = ""
switch p.s[0] {
case '<', '>', '{', '}', ':', '[', ']', ';', ',', '/':
// Single symbol
p.cur.value, p.s = p.s[0:1], p.s[1:len(p.s)]
case '"', '\'':
// Quoted string
i := 1
for i < len(p.s) && p.s[i] != p.s[0] && p.s[i] != '\n' {
if p.s[i] == '\\' && i+1 < len(p.s) {
// skip escaped char
i++
}
i++
}
if i >= len(p.s) || p.s[i] != p.s[0] {
p.errorf("unmatched quote")
return
}
unq, err := unquoteC(p.s[1:i], rune(p.s[0]))
if err != nil {
p.errorf("invalid quoted string %s: %v", p.s[0:i+1], err)
return
}
p.cur.value, p.s = p.s[0:i+1], p.s[i+1:len(p.s)]
p.cur.unquoted = unq
default:
i := 0
for i < len(p.s) && isIdentOrNumberChar(p.s[i]) {
i++
}
if i == 0 {
p.errorf("unexpected byte %#x", p.s[0])
return
}
p.cur.value, p.s = p.s[0:i], p.s[i:len(p.s)]
}
p.offset += len(p.cur.value)
}
var (
errBadUTF8 = errors.New("proto: bad UTF-8")
)
func unquoteC(s string, quote rune) (string, error) {
// This is based on C++'s tokenizer.cc.
// Despite its name, this is *not* parsing C syntax.
// For instance, "\0" is an invalid quoted string.
// Avoid allocation in trivial cases.
simple := true
for _, r := range s {
if r == '\\' || r == quote {
simple = false
break
}
}
if simple {
return s, nil
}
buf := make([]byte, 0, 3*len(s)/2)
for len(s) > 0 {
r, n := utf8.DecodeRuneInString(s)
if r == utf8.RuneError && n == 1 {
return "", errBadUTF8
}
s = s[n:]
if r != '\\' {
if r < utf8.RuneSelf {
buf = append(buf, byte(r))
} else {
buf = append(buf, string(r)...)
}
continue
}
ch, tail, err := unescape(s)
if err != nil {
return "", err
}
buf = append(buf, ch...)
s = tail
}
return string(buf), nil
}
func unescape(s string) (ch string, tail string, err error) {
r, n := utf8.DecodeRuneInString(s)
if r == utf8.RuneError && n == 1 {
return "", "", errBadUTF8
}
s = s[n:]
switch r {
case 'a':
return "\a", s, nil
case 'b':
return "\b", s, nil
case 'f':
return "\f", s, nil
case 'n':
return "\n", s, nil
case 'r':
return "\r", s, nil
case 't':
return "\t", s, nil
case 'v':
return "\v", s, nil
case '?':
return "?", s, nil // trigraph workaround
case '\'', '"', '\\':
return string(r), s, nil
case '0', '1', '2', '3', '4', '5', '6', '7':
if len(s) < 2 {
return "", "", fmt.Errorf(`\%c requires 2 following digits`, r)
}
ss := string(r) + s[:2]
s = s[2:]
i, err := strconv.ParseUint(ss, 8, 8)
if err != nil {
return "", "", fmt.Errorf(`\%s contains non-octal digits`, ss)
}
return string([]byte{byte(i)}), s, nil
case 'x', 'X', 'u', 'U':
var n int
switch r {
case 'x', 'X':
n = 2
case 'u':
n = 4
case 'U':
n = 8
}
if len(s) < n {
return "", "", fmt.Errorf(`\%c requires %d following digits`, r, n)
}
ss := s[:n]
s = s[n:]
i, err := strconv.ParseUint(ss, 16, 64)
if err != nil {
return "", "", fmt.Errorf(`\%c%s contains non-hexadecimal digits`, r, ss)
}
if r == 'x' || r == 'X' {
return string([]byte{byte(i)}), s, nil
}
if i > utf8.MaxRune {
return "", "", fmt.Errorf(`\%c%s is not a valid Unicode code point`, r, ss)
}
return string(i), s, nil
}
return "", "", fmt.Errorf(`unknown escape \%c`, r)
}
// Back off the parser by one token. Can only be done between calls to next().
// It makes the next advance() a no-op.
func (p *textParser) back() { p.backed = true }
// Advances the parser and returns the new current token.
func (p *textParser) next() *token {
if p.backed || p.done {
p.backed = false
return &p.cur
}
p.advance()
if p.done {
p.cur.value = ""
} else if len(p.cur.value) > 0 && isQuote(p.cur.value[0]) {
// Look for multiple quoted strings separated by whitespace,
// and concatenate them.
cat := p.cur
for {
p.skipWhitespace()
if p.done || !isQuote(p.s[0]) {
break
}
p.advance()
if p.cur.err != nil {
return &p.cur
}
cat.value += " " + p.cur.value
cat.unquoted += p.cur.unquoted
}
p.done = false // parser may have seen EOF, but we want to return cat
p.cur = cat
}
return &p.cur
}
func (p *textParser) consumeToken(s string) error {
tok := p.next()
if tok.err != nil {
return tok.err
}
if tok.value != s {
p.back()
return p.errorf("expected %q, found %q", s, tok.value)
}
return nil
}
// Return a RequiredNotSetError indicating which required field was not set.
func (p *textParser) missingRequiredFieldError(sv reflect.Value) *RequiredNotSetError {
st := sv.Type()
sprops := GetProperties(st)
for i := 0; i < st.NumField(); i++ {
if !isNil(sv.Field(i)) {
continue
}
props := sprops.Prop[i]
if props.Required {
return &RequiredNotSetError{fmt.Sprintf("%v.%v", st, props.OrigName)}
}
}
return &RequiredNotSetError{fmt.Sprintf("%v.<unknown field name>", st)} // should not happen
}
// Returns the index in the struct for the named field, as well as the parsed tag properties.
func structFieldByName(sprops *StructProperties, name string) (int, *Properties, bool) {
i, ok := sprops.decoderOrigNames[name]
if ok {
return i, sprops.Prop[i], true
}
return -1, nil, false
}
// Consume a ':' from the input stream (if the next token is a colon),
// returning an error if a colon is needed but not present.
func (p *textParser) checkForColon(props *Properties, typ reflect.Type) *ParseError {
tok := p.next()
if tok.err != nil {
return tok.err
}
if tok.value != ":" {
// Colon is optional when the field is a group or message.
needColon := true
switch props.Wire {
case "group":
needColon = false
case "bytes":
// A "bytes" field is either a message, a string, or a repeated field;
// those three become *T, *string and []T respectively, so we can check for
// this field being a pointer to a non-string.
if typ.Kind() == reflect.Ptr {
// *T or *string
if typ.Elem().Kind() == reflect.String {
break
}
} else if typ.Kind() == reflect.Slice {
// []T or []*T
if typ.Elem().Kind() != reflect.Ptr {
break
}
} else if typ.Kind() == reflect.String {
// The proto3 exception is for a string field,
// which requires a colon.
break
}
needColon = false
}
if needColon {
return p.errorf("expected ':', found %q", tok.value)
}
p.back()
}
return nil
}
func (p *textParser) readStruct(sv reflect.Value, terminator string) error {
st := sv.Type()
sprops := GetProperties(st)
reqCount := sprops.reqCount
var reqFieldErr error
fieldSet := make(map[string]bool)
// A struct is a sequence of "name: value", terminated by one of
// '>' or '}', or the end of the input. A name may also be
// "[extension]" or "[type/url]".
//
// The whole struct can also be an expanded Any message, like:
// [type/url] < ... struct contents ... >
for {
tok := p.next()
if tok.err != nil {
return tok.err
}
if tok.value == terminator {
break
}
if tok.value == "[" {
// Looks like an extension or an Any.
//
// TODO: Check whether we need to handle
// namespace rooted names (e.g. ".something.Foo").
extName, err := p.consumeExtName()
if err != nil {
return err
}
if s := strings.LastIndex(extName, "/"); s >= 0 {
// If it contains a slash, it's an Any type URL.
messageName := extName[s+1:]
mt := MessageType(messageName)
if mt == nil {
return p.errorf("unrecognized message %q in google.protobuf.Any", messageName)
}
tok = p.next()
if tok.err != nil {
return tok.err
}
// consume an optional colon
if tok.value == ":" {
tok = p.next()
if tok.err != nil {
return tok.err
}
}
var terminator string
switch tok.value {
case "<":
terminator = ">"
case "{":
terminator = "}"
default:
return p.errorf("expected '{' or '<', found %q", tok.value)
}
v := reflect.New(mt.Elem())
if pe := p.readStruct(v.Elem(), terminator); pe != nil {
return pe
}
b, err := Marshal(v.Interface().(Message))
if err != nil {
return p.errorf("failed to marshal message of type %q: %v", messageName, err)
}
if fieldSet["type_url"] {
return p.errorf(anyRepeatedlyUnpacked, "type_url")
}
if fieldSet["value"] {
return p.errorf(anyRepeatedlyUnpacked, "value")
}
sv.FieldByName("TypeUrl").SetString(extName)
sv.FieldByName("Value").SetBytes(b)
fieldSet["type_url"] = true
fieldSet["value"] = true
continue
}
var desc *ExtensionDesc
// This could be faster, but it's functional.
// TODO: Do something smarter than a linear scan.
for _, d := range RegisteredExtensions(reflect.New(st).Interface().(Message)) {
if d.Name == extName {
desc = d
break
}
}
if desc == nil {
return p.errorf("unrecognized extension %q", extName)
}
props := &Properties{}
props.Parse(desc.Tag)
typ := reflect.TypeOf(desc.ExtensionType)
if err := p.checkForColon(props, typ); err != nil {
return err
}
rep := desc.repeated()
// Read the extension structure, and set it in
// the value we're constructing.
var ext reflect.Value
if !rep {
ext = reflect.New(typ).Elem()
} else {
ext = reflect.New(typ.Elem()).Elem()
}
if err := p.readAny(ext, props); err != nil {
if _, ok := err.(*RequiredNotSetError); !ok {
return err
}
reqFieldErr = err
}
ep := sv.Addr().Interface().(Message)
if !rep {
SetExtension(ep, desc, ext.Interface())
} else {
old, err := GetExtension(ep, desc)
var sl reflect.Value
if err == nil {
sl = reflect.ValueOf(old) // existing slice
} else {
sl = reflect.MakeSlice(typ, 0, 1)
}
sl = reflect.Append(sl, ext)
SetExtension(ep, desc, sl.Interface())
}
if err := p.consumeOptionalSeparator(); err != nil {
return err
}
continue
}
// This is a normal, non-extension field.
name := tok.value
var dst reflect.Value
fi, props, ok := structFieldByName(sprops, name)
if ok {
dst = sv.Field(fi)
} else if oop, ok := sprops.OneofTypes[name]; ok {
// It is a oneof.
props = oop.Prop
nv := reflect.New(oop.Type.Elem())
dst = nv.Elem().Field(0)
field := sv.Field(oop.Field)
if !field.IsNil() {
return p.errorf("field '%s' would overwrite already parsed oneof '%s'", name, sv.Type().Field(oop.Field).Name)
}
field.Set(nv)
}
if !dst.IsValid() {
return p.errorf("unknown field name %q in %v", name, st)
}
if dst.Kind() == reflect.Map {
// Consume any colon.
if err := p.checkForColon(props, dst.Type()); err != nil {
return err
}
// Construct the map if it doesn't already exist.
if dst.IsNil() {
dst.Set(reflect.MakeMap(dst.Type()))
}
key := reflect.New(dst.Type().Key()).Elem()
val := reflect.New(dst.Type().Elem()).Elem()
// The map entry should be this sequence of tokens:
// < key : KEY value : VALUE >
// However, implementations may omit key or value, and technically
// we should support them in any order. See b/28924776 for a time
// this went wrong.
tok := p.next()
var terminator string
switch tok.value {
case "<":
terminator = ">"
case "{":
terminator = "}"
default:
return p.errorf("expected '{' or '<', found %q", tok.value)
}
for {
tok := p.next()
if tok.err != nil {
return tok.err
}
if tok.value == terminator {
break
}
switch tok.value {
case "key":
if err := p.consumeToken(":"); err != nil {
return err
}
if err := p.readAny(key, props.MapKeyProp); err != nil {
return err
}
if err := p.consumeOptionalSeparator(); err != nil {
return err
}
case "value":
if err := p.checkForColon(props.MapValProp, dst.Type().Elem()); err != nil {
return err
}
if err := p.readAny(val, props.MapValProp); err != nil {
return err
}
if err := p.consumeOptionalSeparator(); err != nil {
return err
}
default:
p.back()
return p.errorf(`expected "key", "value", or %q, found %q`, terminator, tok.value)
}
}
dst.SetMapIndex(key, val)
continue
}
// Check that it's not already set if it's not a repeated field.
if !props.Repeated && fieldSet[name] {
return p.errorf("non-repeated field %q was repeated", name)
}
if err := p.checkForColon(props, dst.Type()); err != nil {
return err
}
// Parse into the field.
fieldSet[name] = true
if err := p.readAny(dst, props); err != nil {
if _, ok := err.(*RequiredNotSetError); !ok {
return err
}
reqFieldErr = err
}
if props.Required {
reqCount--
}
if err := p.consumeOptionalSeparator(); err != nil {
return err
}
}
if reqCount > 0 {
return p.missingRequiredFieldError(sv)
}
return reqFieldErr
}
// consumeExtName consumes extension name or expanded Any type URL and the
// following ']'. It returns the name or URL consumed.
func (p *textParser) consumeExtName() (string, error) {
tok := p.next()
if tok.err != nil {
return "", tok.err
}
// If extension name or type url is quoted, it's a single token.
if len(tok.value) > 2 && isQuote(tok.value[0]) && tok.value[len(tok.value)-1] == tok.value[0] {
name, err := unquoteC(tok.value[1:len(tok.value)-1], rune(tok.value[0]))
if err != nil {
return "", err
}
return name, p.consumeToken("]")
}
// Consume everything up to "]"
var parts []string
for tok.value != "]" {
parts = append(parts, tok.value)
tok = p.next()
if tok.err != nil {
return "", p.errorf("unrecognized type_url or extension name: %s", tok.err)
}
if p.done && tok.value != "]" {
return "", p.errorf("unclosed type_url or extension name")
}
}
return strings.Join(parts, ""), nil
}
// consumeOptionalSeparator consumes an optional semicolon or comma.
// It is used in readStruct to provide backward compatibility.
func (p *textParser) consumeOptionalSeparator() error {
tok := p.next()
if tok.err != nil {
return tok.err
}
if tok.value != ";" && tok.value != "," {
p.back()
}
return nil
}
func (p *textParser) readAny(v reflect.Value, props *Properties) error {
tok := p.next()
if tok.err != nil {
return tok.err
}
if tok.value == "" {
return p.errorf("unexpected EOF")
}
switch fv := v; fv.Kind() {
case reflect.Slice:
at := v.Type()
if at.Elem().Kind() == reflect.Uint8 {
// Special case for []byte
if tok.value[0] != '"' && tok.value[0] != '\'' {
// Deliberately written out here, as the error after
// this switch statement would write "invalid []byte: ...",
// which is not as user-friendly.
return p.errorf("invalid string: %v", tok.value)
}
bytes := []byte(tok.unquoted)
fv.Set(reflect.ValueOf(bytes))
return nil
}
// Repeated field.
if tok.value == "[" {
// Repeated field with list notation, like [1,2,3].
for {
fv.Set(reflect.Append(fv, reflect.New(at.Elem()).Elem()))
err := p.readAny(fv.Index(fv.Len()-1), props)
if err != nil {
return err
}
tok := p.next()
if tok.err != nil {
return tok.err
}
if tok.value == "]" {
break
}
if tok.value != "," {
return p.errorf("Expected ']' or ',' found %q", tok.value)
}
}
return nil
}
// One value of the repeated field.
p.back()
fv.Set(reflect.Append(fv, reflect.New(at.Elem()).Elem()))
return p.readAny(fv.Index(fv.Len()-1), props)
case reflect.Bool:
// true/1/t/True or false/f/0/False.
switch tok.value {
case "true", "1", "t", "True":
fv.SetBool(true)
return nil
case "false", "0", "f", "False":
fv.SetBool(false)
return nil
}
case reflect.Float32, reflect.Float64:
v := tok.value
// Ignore 'f' for compatibility with output generated by C++, but don't
// remove 'f' when the value is "-inf" or "inf".
if strings.HasSuffix(v, "f") && tok.value != "-inf" && tok.value != "inf" {
v = v[:len(v)-1]
}
if f, err := strconv.ParseFloat(v, fv.Type().Bits()); err == nil {
fv.SetFloat(f)
return nil
}
case reflect.Int32:
if x, err := strconv.ParseInt(tok.value, 0, 32); err == nil {
fv.SetInt(x)
return nil
}
if len(props.Enum) == 0 {
break
}
m, ok := enumValueMaps[props.Enum]
if !ok {
break
}
x, ok := m[tok.value]
if !ok {
break
}
fv.SetInt(int64(x))
return nil
case reflect.Int64:
if x, err := strconv.ParseInt(tok.value, 0, 64); err == nil {
fv.SetInt(x)
return nil
}
case reflect.Ptr:
// A basic field (indirected through pointer), or a repeated message/group
p.back()
fv.Set(reflect.New(fv.Type().Elem()))
return p.readAny(fv.Elem(), props)
case reflect.String:
if tok.value[0] == '"' || tok.value[0] == '\'' {
fv.SetString(tok.unquoted)
return nil
}
case reflect.Struct:
var terminator string
switch tok.value {
case "{":
terminator = "}"
case "<":
terminator = ">"
default:
return p.errorf("expected '{' or '<', found %q", tok.value)
}
// TODO: Handle nested messages which implement encoding.TextUnmarshaler.
return p.readStruct(fv, terminator)
case reflect.Uint32:
if x, err := strconv.ParseUint(tok.value, 0, 32); err == nil {
fv.SetUint(uint64(x))
return nil
}
case reflect.Uint64:
if x, err := strconv.ParseUint(tok.value, 0, 64); err == nil {
fv.SetUint(x)
return nil
}
}
return p.errorf("invalid %v: %v", v.Type(), tok.value)
}
// UnmarshalText reads a protocol buffer in Text format. UnmarshalText resets pb
// before starting to unmarshal, so any existing data in pb is always removed.
// If a required field is not set and no other error occurs,
// UnmarshalText returns *RequiredNotSetError.
func UnmarshalText(s string, pb Message) error {
if um, ok := pb.(encoding.TextUnmarshaler); ok {
return um.UnmarshalText([]byte(s))
}
pb.Reset()
v := reflect.ValueOf(pb)
return newTextParser(s).readStruct(v.Elem(), "")
}

78
vendor/github.com/golang/protobuf/proto/wire.go generated vendored Normal file
View file

@ -0,0 +1,78 @@
// Copyright 2019 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
package proto
import (
protoV2 "google.golang.org/protobuf/proto"
"google.golang.org/protobuf/runtime/protoiface"
)
// Size returns the size in bytes of the wire-format encoding of m.
func Size(m Message) int {
if m == nil {
return 0
}
mi := MessageV2(m)
return protoV2.Size(mi)
}
// Marshal returns the wire-format encoding of m.
func Marshal(m Message) ([]byte, error) {
b, err := marshalAppend(nil, m, false)
if b == nil {
b = zeroBytes
}
return b, err
}
var zeroBytes = make([]byte, 0, 0)
func marshalAppend(buf []byte, m Message, deterministic bool) ([]byte, error) {
if m == nil {
return nil, ErrNil
}
mi := MessageV2(m)
nbuf, err := protoV2.MarshalOptions{
Deterministic: deterministic,
AllowPartial: true,
}.MarshalAppend(buf, mi)
if err != nil {
return buf, err
}
if len(buf) == len(nbuf) {
if !mi.ProtoReflect().IsValid() {
return buf, ErrNil
}
}
return nbuf, checkRequiredNotSet(mi)
}
// Unmarshal parses a wire-format message in b and places the decoded results in m.
//
// Unmarshal resets m before starting to unmarshal, so any existing data in m is always
// removed. Use UnmarshalMerge to preserve and append to existing data.
func Unmarshal(b []byte, m Message) error {
m.Reset()
return UnmarshalMerge(b, m)
}
// UnmarshalMerge parses a wire-format message in b and places the decoded results in m.
func UnmarshalMerge(b []byte, m Message) error {
mi := MessageV2(m)
out, err := protoV2.UnmarshalOptions{
AllowPartial: true,
Merge: true,
}.UnmarshalState(protoiface.UnmarshalInput{
Buf: b,
Message: mi.ProtoReflect(),
})
if err != nil {
return err
}
if out.Flags&protoiface.UnmarshalInitialized > 0 {
return nil
}
return checkRequiredNotSet(mi)
}

34
vendor/github.com/golang/protobuf/proto/wrappers.go generated vendored Normal file
View file

@ -0,0 +1,34 @@
// Copyright 2019 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
package proto
// Bool stores v in a new bool value and returns a pointer to it.
func Bool(v bool) *bool { return &v }
// Int stores v in a new int32 value and returns a pointer to it.
//
// Deprecated: Use Int32 instead.
func Int(v int) *int32 { return Int32(int32(v)) }
// Int32 stores v in a new int32 value and returns a pointer to it.
func Int32(v int32) *int32 { return &v }
// Int64 stores v in a new int64 value and returns a pointer to it.
func Int64(v int64) *int64 { return &v }
// Uint32 stores v in a new uint32 value and returns a pointer to it.
func Uint32(v uint32) *uint32 { return &v }
// Uint64 stores v in a new uint64 value and returns a pointer to it.
func Uint64(v uint64) *uint64 { return &v }
// Float32 stores v in a new float32 value and returns a pointer to it.
func Float32(v float32) *float32 { return &v }
// Float64 stores v in a new float64 value and returns a pointer to it.
func Float64(v float64) *float64 { return &v }
// String stores v in a new string value and returns a pointer to it.
func String(v string) *string { return &v }

3047
vendor/github.com/golang/protobuf/protoc-gen-go/descriptor/descriptor.pb.go generated vendored
View file

File diff suppressed because it is too large Load diff

885
vendor/github.com/golang/protobuf/protoc-gen-go/descriptor/descriptor.proto generated vendored
View file

@ -1,885 +0,0 @@
// Protocol Buffers - Google's data interchange format
// Copyright 2008 Google Inc. All rights reserved.
// https://developers.google.com/protocol-buffers/
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
// * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
// * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following disclaimer
// in the documentation and/or other materials provided with the
// distribution.
// * Neither the name of Google Inc. nor the names of its
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
// Author: kenton@google.com (Kenton Varda)
// Based on original Protocol Buffers design by
// Sanjay Ghemawat, Jeff Dean, and others.
//
// The messages in this file describe the definitions found in .proto files.
// A valid .proto file can be translated directly to a FileDescriptorProto
// without any other information (e.g. without reading its imports).
syntax = "proto2";
package google.protobuf;
option go_package = "github.com/golang/protobuf/protoc-gen-go/descriptor;descriptor";
option java_package = "com.google.protobuf";
option java_outer_classname = "DescriptorProtos";
option csharp_namespace = "Google.Protobuf.Reflection";
option objc_class_prefix = "GPB";
option cc_enable_arenas = true;
// descriptor.proto must be optimized for speed because reflection-based
// algorithms don't work during bootstrapping.
option optimize_for = SPEED;
// The protocol compiler can output a FileDescriptorSet containing the .proto
// files it parses.
message FileDescriptorSet {
repeated FileDescriptorProto file = 1;
}
// Describes a complete .proto file.
message FileDescriptorProto {
optional string name = 1; // file name, relative to root of source tree
optional string package = 2; // e.g. "foo", "foo.bar", etc.
// Names of files imported by this file.
repeated string dependency = 3;
// Indexes of the public imported files in the dependency list above.
repeated int32 public_dependency = 10;
// Indexes of the weak imported files in the dependency list.
// For Google-internal migration only. Do not use.
repeated int32 weak_dependency = 11;
// All top-level definitions in this file.
repeated DescriptorProto message_type = 4;
repeated EnumDescriptorProto enum_type = 5;
repeated ServiceDescriptorProto service = 6;
repeated FieldDescriptorProto extension = 7;
optional FileOptions options = 8;
// This field contains optional information about the original source code.
// You may safely remove this entire field without harming runtime
// functionality of the descriptors -- the information is needed only by
// development tools.
optional SourceCodeInfo source_code_info = 9;
// The syntax of the proto file.
// The supported values are "proto2" and "proto3".
optional string syntax = 12;
}
// Describes a message type.
message DescriptorProto {
optional string name = 1;
repeated FieldDescriptorProto field = 2;
repeated FieldDescriptorProto extension = 6;
repeated DescriptorProto nested_type = 3;
repeated EnumDescriptorProto enum_type = 4;
message ExtensionRange {
optional int32 start = 1; // Inclusive.
optional int32 end = 2; // Exclusive.
optional ExtensionRangeOptions options = 3;
}
repeated ExtensionRange extension_range = 5;
repeated OneofDescriptorProto oneof_decl = 8;
optional MessageOptions options = 7;
// Range of reserved tag numbers. Reserved tag numbers may not be used by
// fields or extension ranges in the same message. Reserved ranges may
// not overlap.
message ReservedRange {
optional int32 start = 1; // Inclusive.
optional int32 end = 2; // Exclusive.
}
repeated ReservedRange reserved_range = 9;
// Reserved field names, which may not be used by fields in the same message.
// A given name may only be reserved once.
repeated string reserved_name = 10;
}
message ExtensionRangeOptions {
// The parser stores options it doesn't recognize here. See above.
repeated UninterpretedOption uninterpreted_option = 999;
// Clients can define custom options in extensions of this message. See above.
extensions 1000 to max;
}
// Describes a field within a message.
message FieldDescriptorProto {
enum Type {
// 0 is reserved for errors.
// Order is weird for historical reasons.
TYPE_DOUBLE = 1;
TYPE_FLOAT = 2;
// Not ZigZag encoded. Negative numbers take 10 bytes. Use TYPE_SINT64 if
// negative values are likely.
TYPE_INT64 = 3;
TYPE_UINT64 = 4;
// Not ZigZag encoded. Negative numbers take 10 bytes. Use TYPE_SINT32 if
// negative values are likely.
TYPE_INT32 = 5;
TYPE_FIXED64 = 6;
TYPE_FIXED32 = 7;
TYPE_BOOL = 8;
TYPE_STRING = 9;
// Tag-delimited aggregate.
// Group type is deprecated and not supported in proto3. However, Proto3
// implementations should still be able to parse the group wire format and
// treat group fields as unknown fields.
TYPE_GROUP = 10;
TYPE_MESSAGE = 11; // Length-delimited aggregate.
// New in version 2.
TYPE_BYTES = 12;
TYPE_UINT32 = 13;
TYPE_ENUM = 14;
TYPE_SFIXED32 = 15;
TYPE_SFIXED64 = 16;
TYPE_SINT32 = 17; // Uses ZigZag encoding.
TYPE_SINT64 = 18; // Uses ZigZag encoding.
}
enum Label {
// 0 is reserved for errors
LABEL_OPTIONAL = 1;
LABEL_REQUIRED = 2;
LABEL_REPEATED = 3;
}
optional string name = 1;
optional int32 number = 3;
optional Label label = 4;
// If type_name is set, this need not be set. If both this and type_name
// are set, this must be one of TYPE_ENUM, TYPE_MESSAGE or TYPE_GROUP.
optional Type type = 5;
// For message and enum types, this is the name of the type. If the name
// starts with a '.', it is fully-qualified. Otherwise, C++-like scoping
// rules are used to find the type (i.e. first the nested types within this
// message are searched, then within the parent, on up to the root
// namespace).
optional string type_name = 6;
// For extensions, this is the name of the type being extended. It is
// resolved in the same manner as type_name.
optional string extendee = 2;
// For numeric types, contains the original text representation of the value.
// For booleans, "true" or "false".
// For strings, contains the default text contents (not escaped in any way).
// For bytes, contains the C escaped value. All bytes >= 128 are escaped.
// TODO(kenton): Base-64 encode?
optional string default_value = 7;
// If set, gives the index of a oneof in the containing type's oneof_decl
// list. This field is a member of that oneof.
optional int32 oneof_index = 9;
// JSON name of this field. The value is set by protocol compiler. If the
// user has set a "json_name" option on this field, that option's value
// will be used. Otherwise, it's deduced from the field's name by converting
// it to camelCase.
optional string json_name = 10;
optional FieldOptions options = 8;
}
// Describes a oneof.
message OneofDescriptorProto {
optional string name = 1;
optional OneofOptions options = 2;
}
// Describes an enum type.
message EnumDescriptorProto {
optional string name = 1;
repeated EnumValueDescriptorProto value = 2;
optional EnumOptions options = 3;
// Range of reserved numeric values. Reserved values may not be used by
// entries in the same enum. Reserved ranges may not overlap.
//
// Note that this is distinct from DescriptorProto.ReservedRange in that it
// is inclusive such that it can appropriately represent the entire int32
// domain.
message EnumReservedRange {
optional int32 start = 1; // Inclusive.
optional int32 end = 2; // Inclusive.
}
// Range of reserved numeric values. Reserved numeric values may not be used
// by enum values in the same enum declaration. Reserved ranges may not
// overlap.
repeated EnumReservedRange reserved_range = 4;
// Reserved enum value names, which may not be reused. A given name may only
// be reserved once.
repeated string reserved_name = 5;
}
// Describes a value within an enum.
message EnumValueDescriptorProto {
optional string name = 1;
optional int32 number = 2;
optional EnumValueOptions options = 3;
}
// Describes a service.
message ServiceDescriptorProto {
optional string name = 1;
repeated MethodDescriptorProto method = 2;
optional ServiceOptions options = 3;
}
// Describes a method of a service.
message MethodDescriptorProto {
optional string name = 1;
// Input and output type names. These are resolved in the same way as
// FieldDescriptorProto.type_name, but must refer to a message type.
optional string input_type = 2;
optional string output_type = 3;
optional MethodOptions options = 4;
// Identifies if client streams multiple client messages
optional bool client_streaming = 5 [default = false];
// Identifies if server streams multiple server messages
optional bool server_streaming = 6 [default = false];
}
// ===================================================================
// Options
// Each of the definitions above may have "options" attached. These are
// just annotations which may cause code to be generated slightly differently
// or may contain hints for code that manipulates protocol messages.
//
// Clients may define custom options as extensions of the *Options messages.
// These extensions may not yet be known at parsing time, so the parser cannot
// store the values in them. Instead it stores them in a field in the *Options
// message called uninterpreted_option. This field must have the same name
// across all *Options messages. We then use this field to populate the
// extensions when we build a descriptor, at which point all protos have been
// parsed and so all extensions are known.
//
// Extension numbers for custom options may be chosen as follows:
// * For options which will only be used within a single application or
// organization, or for experimental options, use field numbers 50000
// through 99999. It is up to you to ensure that you do not use the
// same number for multiple options.
// * For options which will be published and used publicly by multiple
// independent entities, e-mail protobuf-global-extension-registry@google.com
// to reserve extension numbers. Simply provide your project name (e.g.
// Objective-C plugin) and your project website (if available) -- there's no
// need to explain how you intend to use them. Usually you only need one
// extension number. You can declare multiple options with only one extension
// number by putting them in a sub-message. See the Custom Options section of
// the docs for examples:
// https://developers.google.com/protocol-buffers/docs/proto#options
// If this turns out to be popular, a web service will be set up
// to automatically assign option numbers.
message FileOptions {
// Sets the Java package where classes generated from this .proto will be
// placed. By default, the proto package is used, but this is often
// inappropriate because proto packages do not normally start with backwards
// domain names.
optional string java_package = 1;
// If set, all the classes from the .proto file are wrapped in a single
// outer class with the given name. This applies to both Proto1
// (equivalent to the old "--one_java_file" option) and Proto2 (where
// a .proto always translates to a single class, but you may want to
// explicitly choose the class name).
optional string java_outer_classname = 8;
// If set true, then the Java code generator will generate a separate .java
// file for each top-level message, enum, and service defined in the .proto
// file. Thus, these types will *not* be nested inside the outer class
// named by java_outer_classname. However, the outer class will still be
// generated to contain the file's getDescriptor() method as well as any
// top-level extensions defined in the file.
optional bool java_multiple_files = 10 [default = false];
// This option does nothing.
optional bool java_generate_equals_and_hash = 20 [deprecated=true];
// If set true, then the Java2 code generator will generate code that
// throws an exception whenever an attempt is made to assign a non-UTF-8
// byte sequence to a string field.
// Message reflection will do the same.
// However, an extension field still accepts non-UTF-8 byte sequences.
// This option has no effect on when used with the lite runtime.
optional bool java_string_check_utf8 = 27 [default = false];
// Generated classes can be optimized for speed or code size.
enum OptimizeMode {
SPEED = 1; // Generate complete code for parsing, serialization,
// etc.
CODE_SIZE = 2; // Use ReflectionOps to implement these methods.
LITE_RUNTIME = 3; // Generate code using MessageLite and the lite runtime.
}
optional OptimizeMode optimize_for = 9 [default = SPEED];
// Sets the Go package where structs generated from this .proto will be
// placed. If omitted, the Go package will be derived from the following:
// - The basename of the package import path, if provided.
// - Otherwise, the package statement in the .proto file, if present.
// - Otherwise, the basename of the .proto file, without extension.
optional string go_package = 11;
// Should generic services be generated in each language? "Generic" services
// are not specific to any particular RPC system. They are generated by the
// main code generators in each language (without additional plugins).
// Generic services were the only kind of service generation supported by
// early versions of google.protobuf.
//
// Generic services are now considered deprecated in favor of using plugins
// that generate code specific to your particular RPC system. Therefore,
// these default to false. Old code which depends on generic services should
// explicitly set them to true.
optional bool cc_generic_services = 16 [default = false];
optional bool java_generic_services = 17 [default = false];
optional bool py_generic_services = 18 [default = false];
optional bool php_generic_services = 42 [default = false];
// Is this file deprecated?
// Depending on the target platform, this can emit Deprecated annotations
// for everything in the file, or it will be completely ignored; in the very
// least, this is a formalization for deprecating files.
optional bool deprecated = 23 [default = false];
// Enables the use of arenas for the proto messages in this file. This applies
// only to generated classes for C++.
optional bool cc_enable_arenas = 31 [default = false];
// Sets the objective c class prefix which is prepended to all objective c
// generated classes from this .proto. There is no default.
optional string objc_class_prefix = 36;
// Namespace for generated classes; defaults to the package.
optional string csharp_namespace = 37;
// By default Swift generators will take the proto package and CamelCase it
// replacing '.' with underscore and use that to prefix the types/symbols
// defined. When this options is provided, they will use this value instead
// to prefix the types/symbols defined.
optional string swift_prefix = 39;
// Sets the php class prefix which is prepended to all php generated classes
// from this .proto. Default is empty.
optional string php_class_prefix = 40;
// Use this option to change the namespace of php generated classes. Default
// is empty. When this option is empty, the package name will be used for
// determining the namespace.
optional string php_namespace = 41;
// Use this option to change the namespace of php generated metadata classes.
// Default is empty. When this option is empty, the proto file name will be
// used for determining the namespace.
optional string php_metadata_namespace = 44;
// Use this option to change the package of ruby generated classes. Default
// is empty. When this option is not set, the package name will be used for
// determining the ruby package.
optional string ruby_package = 45;
// The parser stores options it doesn't recognize here.
// See the documentation for the "Options" section above.
repeated UninterpretedOption uninterpreted_option = 999;
// Clients can define custom options in extensions of this message.
// See the documentation for the "Options" section above.
extensions 1000 to max;
reserved 38;
}
message MessageOptions {
// Set true to use the old proto1 MessageSet wire format for extensions.
// This is provided for backwards-compatibility with the MessageSet wire
// format. You should not use this for any other reason: It's less
// efficient, has fewer features, and is more complicated.
//
// The message must be defined exactly as follows:
// message Foo {
// option message_set_wire_format = true;
// extensions 4 to max;
// }
// Note that the message cannot have any defined fields; MessageSets only
// have extensions.
//
// All extensions of your type must be singular messages; e.g. they cannot
// be int32s, enums, or repeated messages.
//
// Because this is an option, the above two restrictions are not enforced by
// the protocol compiler.
optional bool message_set_wire_format = 1 [default = false];
// Disables the generation of the standard "descriptor()" accessor, which can
// conflict with a field of the same name. This is meant to make migration
// from proto1 easier; new code should avoid fields named "descriptor".
optional bool no_standard_descriptor_accessor = 2 [default = false];
// Is this message deprecated?
// Depending on the target platform, this can emit Deprecated annotations
// for the message, or it will be completely ignored; in the very least,
// this is a formalization for deprecating messages.
optional bool deprecated = 3 [default = false];
// Whether the message is an automatically generated map entry type for the
// maps field.
//
// For maps fields:
// map<KeyType, ValueType> map_field = 1;
// The parsed descriptor looks like:
// message MapFieldEntry {
// option map_entry = true;
// optional KeyType key = 1;
// optional ValueType value = 2;
// }
// repeated MapFieldEntry map_field = 1;
//
// Implementations may choose not to generate the map_entry=true message, but
// use a native map in the target language to hold the keys and values.
// The reflection APIs in such implementations still need to work as
// if the field is a repeated message field.
//
// NOTE: Do not set the option in .proto files. Always use the maps syntax
// instead. The option should only be implicitly set by the proto compiler
// parser.
optional bool map_entry = 7;
reserved 8; // javalite_serializable
reserved 9; // javanano_as_lite
// The parser stores options it doesn't recognize here. See above.
repeated UninterpretedOption uninterpreted_option = 999;
// Clients can define custom options in extensions of this message. See above.
extensions 1000 to max;
}
message FieldOptions {
// The ctype option instructs the C++ code generator to use a different
// representation of the field than it normally would. See the specific
// options below. This option is not yet implemented in the open source
// release -- sorry, we'll try to include it in a future version!
optional CType ctype = 1 [default = STRING];
enum CType {
// Default mode.
STRING = 0;
CORD = 1;
STRING_PIECE = 2;
}
// The packed option can be enabled for repeated primitive fields to enable
// a more efficient representation on the wire. Rather than repeatedly
// writing the tag and type for each element, the entire array is encoded as
// a single length-delimited blob. In proto3, only explicit setting it to
// false will avoid using packed encoding.
optional bool packed = 2;
// The jstype option determines the JavaScript type used for values of the
// field. The option is permitted only for 64 bit integral and fixed types
// (int64, uint64, sint64, fixed64, sfixed64). A field with jstype JS_STRING
// is represented as JavaScript string, which avoids loss of precision that
// can happen when a large value is converted to a floating point JavaScript.
// Specifying JS_NUMBER for the jstype causes the generated JavaScript code to
// use the JavaScript "number" type. The behavior of the default option
// JS_NORMAL is implementation dependent.
//
// This option is an enum to permit additional types to be added, e.g.
// goog.math.Integer.
optional JSType jstype = 6 [default = JS_NORMAL];
enum JSType {
// Use the default type.
JS_NORMAL = 0;
// Use JavaScript strings.
JS_STRING = 1;
// Use JavaScript numbers.
JS_NUMBER = 2;
}
// Should this field be parsed lazily? Lazy applies only to message-type
// fields. It means that when the outer message is initially parsed, the
// inner message's contents will not be parsed but instead stored in encoded
// form. The inner message will actually be parsed when it is first accessed.
//
// This is only a hint. Implementations are free to choose whether to use
// eager or lazy parsing regardless of the value of this option. However,
// setting this option true suggests that the protocol author believes that
// using lazy parsing on this field is worth the additional bookkeeping
// overhead typically needed to implement it.
//
// This option does not affect the public interface of any generated code;
// all method signatures remain the same. Furthermore, thread-safety of the
// interface is not affected by this option; const methods remain safe to
// call from multiple threads concurrently, while non-const methods continue
// to require exclusive access.
//
//
// Note that implementations may choose not to check required fields within
// a lazy sub-message. That is, calling IsInitialized() on the outer message
// may return true even if the inner message has missing required fields.
// This is necessary because otherwise the inner message would have to be
// parsed in order to perform the check, defeating the purpose of lazy
// parsing. An implementation which chooses not to check required fields
// must be consistent about it. That is, for any particular sub-message, the
// implementation must either *always* check its required fields, or *never*
// check its required fields, regardless of whether or not the message has
// been parsed.
optional bool lazy = 5 [default = false];
// Is this field deprecated?
// Depending on the target platform, this can emit Deprecated annotations
// for accessors, or it will be completely ignored; in the very least, this
// is a formalization for deprecating fields.
optional bool deprecated = 3 [default = false];
// For Google-internal migration only. Do not use.
optional bool weak = 10 [default = false];
// The parser stores options it doesn't recognize here. See above.
repeated UninterpretedOption uninterpreted_option = 999;
// Clients can define custom options in extensions of this message. See above.
extensions 1000 to max;
reserved 4; // removed jtype
}
message OneofOptions {
// The parser stores options it doesn't recognize here. See above.
repeated UninterpretedOption uninterpreted_option = 999;
// Clients can define custom options in extensions of this message. See above.
extensions 1000 to max;
}
message EnumOptions {
// Set this option to true to allow mapping different tag names to the same
// value.
optional bool allow_alias = 2;
// Is this enum deprecated?
// Depending on the target platform, this can emit Deprecated annotations
// for the enum, or it will be completely ignored; in the very least, this
// is a formalization for deprecating enums.
optional bool deprecated = 3 [default = false];
reserved 5; // javanano_as_lite
// The parser stores options it doesn't recognize here. See above.
repeated UninterpretedOption uninterpreted_option = 999;
// Clients can define custom options in extensions of this message. See above.
extensions 1000 to max;
}
message EnumValueOptions {
// Is this enum value deprecated?
// Depending on the target platform, this can emit Deprecated annotations
// for the enum value, or it will be completely ignored; in the very least,
// this is a formalization for deprecating enum values.
optional bool deprecated = 1 [default = false];
// The parser stores options it doesn't recognize here. See above.
repeated UninterpretedOption uninterpreted_option = 999;
// Clients can define custom options in extensions of this message. See above.
extensions 1000 to max;
}
message ServiceOptions {
// Note: Field numbers 1 through 32 are reserved for Google's internal RPC
// framework. We apologize for hoarding these numbers to ourselves, but
// we were already using them long before we decided to release Protocol
// Buffers.
// Is this service deprecated?
// Depending on the target platform, this can emit Deprecated annotations
// for the service, or it will be completely ignored; in the very least,
// this is a formalization for deprecating services.
optional bool deprecated = 33 [default = false];
// The parser stores options it doesn't recognize here. See above.
repeated UninterpretedOption uninterpreted_option = 999;
// Clients can define custom options in extensions of this message. See above.
extensions 1000 to max;
}
message MethodOptions {
// Note: Field numbers 1 through 32 are reserved for Google's internal RPC
// framework. We apologize for hoarding these numbers to ourselves, but
// we were already using them long before we decided to release Protocol
// Buffers.
// Is this method deprecated?
// Depending on the target platform, this can emit Deprecated annotations
// for the method, or it will be completely ignored; in the very least,
// this is a formalization for deprecating methods.
optional bool deprecated = 33 [default = false];
// Is this method side-effect-free (or safe in HTTP parlance), or idempotent,
// or neither? HTTP based RPC implementation may choose GET verb for safe
// methods, and PUT verb for idempotent methods instead of the default POST.
enum IdempotencyLevel {
IDEMPOTENCY_UNKNOWN = 0;
NO_SIDE_EFFECTS = 1; // implies idempotent
IDEMPOTENT = 2; // idempotent, but may have side effects
}
optional IdempotencyLevel idempotency_level = 34
[default = IDEMPOTENCY_UNKNOWN];
// The parser stores options it doesn't recognize here. See above.
repeated UninterpretedOption uninterpreted_option = 999;
// Clients can define custom options in extensions of this message. See above.
extensions 1000 to max;
}
// A message representing a option the parser does not recognize. This only
// appears in options protos created by the compiler::Parser class.
// DescriptorPool resolves these when building Descriptor objects. Therefore,
// options protos in descriptor objects (e.g. returned by Descriptor::options(),
// or produced by Descriptor::CopyTo()) will never have UninterpretedOptions
// in them.
message UninterpretedOption {
// The name of the uninterpreted option. Each string represents a segment in
// a dot-separated name. is_extension is true iff a segment represents an
// extension (denoted with parentheses in options specs in .proto files).
// E.g.,{ ["foo", false], ["bar.baz", true], ["qux", false] } represents
// "foo.(bar.baz).qux".
message NamePart {
required string name_part = 1;
required bool is_extension = 2;
}
repeated NamePart name = 2;
// The value of the uninterpreted option, in whatever type the tokenizer
// identified it as during parsing. Exactly one of these should be set.
optional string identifier_value = 3;
optional uint64 positive_int_value = 4;
optional int64 negative_int_value = 5;
optional double double_value = 6;
optional bytes string_value = 7;
optional string aggregate_value = 8;
}
// ===================================================================
// Optional source code info
// Encapsulates information about the original source file from which a
// FileDescriptorProto was generated.
message SourceCodeInfo {
// A Location identifies a piece of source code in a .proto file which
// corresponds to a particular definition. This information is intended
// to be useful to IDEs, code indexers, documentation generators, and similar
// tools.
//
// For example, say we have a file like:
// message Foo {
// optional string foo = 1;
// }
// Let's look at just the field definition:
// optional string foo = 1;
// ^ ^^ ^^ ^ ^^^
// a bc de f ghi
// We have the following locations:
// span path represents
// [a,i) [ 4, 0, 2, 0 ] The whole field definition.
// [a,b) [ 4, 0, 2, 0, 4 ] The label (optional).
// [c,d) [ 4, 0, 2, 0, 5 ] The type (string).
// [e,f) [ 4, 0, 2, 0, 1 ] The name (foo).
// [g,h) [ 4, 0, 2, 0, 3 ] The number (1).
//
// Notes:
// - A location may refer to a repeated field itself (i.e. not to any
// particular index within it). This is used whenever a set of elements are
// logically enclosed in a single code segment. For example, an entire
// extend block (possibly containing multiple extension definitions) will
// have an outer location whose path refers to the "extensions" repeated
// field without an index.
// - Multiple locations may have the same path. This happens when a single
// logical declaration is spread out across multiple places. The most
// obvious example is the "extend" block again -- there may be multiple
// extend blocks in the same scope, each of which will have the same path.
// - A location's span is not always a subset of its parent's span. For
// example, the "extendee" of an extension declaration appears at the
// beginning of the "extend" block and is shared by all extensions within
// the block.
// - Just because a location's span is a subset of some other location's span
// does not mean that it is a descendant. For example, a "group" defines
// both a type and a field in a single declaration. Thus, the locations
// corresponding to the type and field and their components will overlap.
// - Code which tries to interpret locations should probably be designed to
// ignore those that it doesn't understand, as more types of locations could
// be recorded in the future.
repeated Location location = 1;
message Location {
// Identifies which part of the FileDescriptorProto was defined at this
// location.
//
// Each element is a field number or an index. They form a path from
// the root FileDescriptorProto to the place where the definition. For
// example, this path:
// [ 4, 3, 2, 7, 1 ]
// refers to:
// file.message_type(3) // 4, 3
// .field(7) // 2, 7
// .name() // 1
// This is because FileDescriptorProto.message_type has field number 4:
// repeated DescriptorProto message_type = 4;
// and DescriptorProto.field has field number 2:
// repeated FieldDescriptorProto field = 2;
// and FieldDescriptorProto.name has field number 1:
// optional string name = 1;
//
// Thus, the above path gives the location of a field name. If we removed
// the last element:
// [ 4, 3, 2, 7 ]
// this path refers to the whole field declaration (from the beginning
// of the label to the terminating semicolon).
repeated int32 path = 1 [packed = true];
// Always has exactly three or four elements: start line, start column,
// end line (optional, otherwise assumed same as start line), end column.
// These are packed into a single field for efficiency. Note that line
// and column numbers are zero-based -- typically you will want to add
// 1 to each before displaying to a user.
repeated int32 span = 2 [packed = true];
// If this SourceCodeInfo represents a complete declaration, these are any
// comments appearing before and after the declaration which appear to be
// attached to the declaration.
//
// A series of line comments appearing on consecutive lines, with no other
// tokens appearing on those lines, will be treated as a single comment.
//
// leading_detached_comments will keep paragraphs of comments that appear
// before (but not connected to) the current element. Each paragraph,
// separated by empty lines, will be one comment element in the repeated
// field.
//
// Only the comment content is provided; comment markers (e.g. //) are
// stripped out. For block comments, leading whitespace and an asterisk
// will be stripped from the beginning of each line other than the first.
// Newlines are included in the output.
//
// Examples:
//
// optional int32 foo = 1; // Comment attached to foo.
// // Comment attached to bar.
// optional int32 bar = 2;
//
// optional string baz = 3;
// // Comment attached to baz.
// // Another line attached to baz.
//
// // Comment attached to qux.
// //
// // Another line attached to qux.
// optional double qux = 4;
//
// // Detached comment for corge. This is not leading or trailing comments
// // to qux or corge because there are blank lines separating it from
// // both.
//
// // Detached comment for corge paragraph 2.
//
// optional string corge = 5;
// /* Block comment attached
// * to corge. Leading asterisks
// * will be removed. */
// /* Block comment attached to
// * grault. */
// optional int32 grault = 6;
//
// // ignored detached comments.
optional string leading_comments = 3;
optional string trailing_comments = 4;
repeated string leading_detached_comments = 6;
}
}
// Describes the relationship between generated code and its original source
// file. A GeneratedCodeInfo message is associated with only one generated
// source file, but may contain references to different source .proto files.
message GeneratedCodeInfo {
// An Annotation connects some span of text in generated code to an element
// of its generating .proto file.
repeated Annotation annotation = 1;
message Annotation {
// Identifies the element in the original source .proto file. This field
// is formatted the same as SourceCodeInfo.Location.path.
repeated int32 path = 1 [packed = true];
// Identifies the filesystem path to the original source .proto.
optional string source_file = 2;
// Identifies the starting offset in bytes in the generated code
// that relates to the identified object.
optional int32 begin = 3;
// Identifies the ending offset in bytes in the generated code that
// relates to the identified offset. The end offset should be one past
// the last relevant byte (so the length of the text = end - begin).
optional int32 end = 4;
}
}

51
vendor/github.com/golang/protobuf/protoc-gen-go/doc.go generated vendored
View file

@ -1,51 +0,0 @@
// Go support for Protocol Buffers - Google's data interchange format
//
// Copyright 2010 The Go Authors. All rights reserved.
// https://github.com/golang/protobuf
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
// * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
// * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following disclaimer
// in the documentation and/or other materials provided with the
// distribution.
// * Neither the name of Google Inc. nor the names of its
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
/*
A plugin for the Google protocol buffer compiler to generate Go code.
Run it by building this program and putting it in your path with the name
protoc-gen-go
That word 'go' at the end becomes part of the option string set for the
protocol compiler, so once the protocol compiler (protoc) is installed
you can run
protoc --go_out=output_directory input_directory/file.proto
to generate Go bindings for the protocol defined by file.proto.
With that input, the output will be written to
output_directory/file.pb.go
The generated code is documented in the package comment for
the library.
See the README and documentation for protocol buffers to learn more:
https://developers.google.com/protocol-buffers/
*/
package documentation

2808
vendor/github.com/golang/protobuf/protoc-gen-go/generator/generator.go generated vendored
View file

File diff suppressed because it is too large Load diff

117
vendor/github.com/golang/protobuf/protoc-gen-go/generator/internal/remap/remap.go generated vendored
View file

@ -1,117 +0,0 @@
// Go support for Protocol Buffers - Google's data interchange format
//
// Copyright 2017 The Go Authors. All rights reserved.
// https://github.com/golang/protobuf
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
// * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
// * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following disclaimer
// in the documentation and/or other materials provided with the
// distribution.
// * Neither the name of Google Inc. nor the names of its
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
/*
Package remap handles tracking the locations of Go tokens in a source text
across a rewrite by the Go formatter.
*/
package remap
import (
"fmt"
"go/scanner"
"go/token"
)
// A Location represents a span of byte offsets in the source text.
type Location struct {
Pos, End int // End is exclusive
}
// A Map represents a mapping between token locations in an input source text
// and locations in the corresponding output text.
type Map map[Location]Location
// Find reports whether the specified span is recorded by m, and if so returns
// the new location it was mapped to. If the input span was not found, the
// returned location is the same as the input.
func (m Map) Find(pos, end int) (Location, bool) {
key := Location{
Pos: pos,
End: end,
}
if loc, ok := m[key]; ok {
return loc, true
}
return key, false
}
func (m Map) add(opos, oend, npos, nend int) {
m[Location{Pos: opos, End: oend}] = Location{Pos: npos, End: nend}
}
// Compute constructs a location mapping from input to output. An error is
// reported if any of the tokens of output cannot be mapped.
func Compute(input, output []byte) (Map, error) {
itok := tokenize(input)
otok := tokenize(output)
if len(itok) != len(otok) {
return nil, fmt.Errorf("wrong number of tokens, %d ≠ %d", len(itok), len(otok))
}
m := make(Map)
for i, ti := range itok {
to := otok[i]
if ti.Token != to.Token {
return nil, fmt.Errorf("token %d type mismatch: %s ≠ %s", i+1, ti, to)
}
m.add(ti.pos, ti.end, to.pos, to.end)
}
return m, nil
}
// tokinfo records the span and type of a source token.
type tokinfo struct {
pos, end int
token.Token
}
func tokenize(src []byte) []tokinfo {
fs := token.NewFileSet()
var s scanner.Scanner
s.Init(fs.AddFile("src", fs.Base(), len(src)), src, nil, scanner.ScanComments)
var info []tokinfo
for {
pos, next, lit := s.Scan()
switch next {
case token.SEMICOLON:
continue
}
info = append(info, tokinfo{
pos: int(pos - 1),
end: int(pos + token.Pos(len(lit)) - 1),
Token: next,
})
if next == token.EOF {
break
}
}
return info
}

545
vendor/github.com/golang/protobuf/protoc-gen-go/grpc/grpc.go generated vendored
View file

@ -1,545 +0,0 @@
// Go support for Protocol Buffers - Google's data interchange format
//
// Copyright 2015 The Go Authors. All rights reserved.
// https://github.com/golang/protobuf
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
// * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
// * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following disclaimer
// in the documentation and/or other materials provided with the
// distribution.
// * Neither the name of Google Inc. nor the names of its
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
// Package grpc outputs gRPC service descriptions in Go code.
// It runs as a plugin for the Go protocol buffer compiler plugin.
// It is linked in to protoc-gen-go.
package grpc
import (
"fmt"
"strconv"
"strings"
pb "github.com/golang/protobuf/protoc-gen-go/descriptor"
"github.com/golang/protobuf/protoc-gen-go/generator"
)
// generatedCodeVersion indicates a version of the generated code.
// It is incremented whenever an incompatibility between the generated code and
// the grpc package is introduced; the generated code references
// a constant, grpc.SupportPackageIsVersionN (where N is generatedCodeVersion).
const generatedCodeVersion = 6
// Paths for packages used by code generated in this file,
// relative to the import_prefix of the generator.Generator.
const (
contextPkgPath = "context"
grpcPkgPath = "google.golang.org/grpc"
codePkgPath = "google.golang.org/grpc/codes"
statusPkgPath = "google.golang.org/grpc/status"
)
func init() {
generator.RegisterPlugin(new(grpc))
}
// grpc is an implementation of the Go protocol buffer compiler's
// plugin architecture. It generates bindings for gRPC support.
type grpc struct {
gen *generator.Generator
}
// Name returns the name of this plugin, "grpc".
func (g *grpc) Name() string {
return "grpc"
}
// The names for packages imported in the generated code.
// They may vary from the final path component of the import path
// if the name is used by other packages.
var (
contextPkg string
grpcPkg string
)
// Init initializes the plugin.
func (g *grpc) Init(gen *generator.Generator) {
g.gen = gen
}
// Given a type name defined in a .proto, return its object.
// Also record that we're using it, to guarantee the associated import.
func (g *grpc) objectNamed(name string) generator.Object {
g.gen.RecordTypeUse(name)
return g.gen.ObjectNamed(name)
}
// Given a type name defined in a .proto, return its name as we will print it.
func (g *grpc) typeName(str string) string {
return g.gen.TypeName(g.objectNamed(str))
}
// P forwards to g.gen.P.
func (g *grpc) P(args ...interface{}) { g.gen.P(args...) }
// Generate generates code for the services in the given file.
func (g *grpc) Generate(file *generator.FileDescriptor) {
if len(file.FileDescriptorProto.Service) == 0 {
return
}
contextPkg = string(g.gen.AddImport(contextPkgPath))
grpcPkg = string(g.gen.AddImport(grpcPkgPath))
g.P("// Reference imports to suppress errors if they are not otherwise used.")
g.P("var _ ", contextPkg, ".Context")
g.P("var _ ", grpcPkg, ".ClientConnInterface")
g.P()
// Assert version compatibility.
g.P("// This is a compile-time assertion to ensure that this generated file")
g.P("// is compatible with the grpc package it is being compiled against.")
g.P("const _ = ", grpcPkg, ".SupportPackageIsVersion", generatedCodeVersion)
g.P()
for i, service := range file.FileDescriptorProto.Service {
g.generateService(file, service, i)
}
}
// GenerateImports generates the import declaration for this file.
func (g *grpc) GenerateImports(file *generator.FileDescriptor) {
}
// reservedClientName records whether a client name is reserved on the client side.
var reservedClientName = map[string]bool{
// TODO: do we need any in gRPC?
}
func unexport(s string) string { return strings.ToLower(s[:1]) + s[1:] }
// deprecationComment is the standard comment added to deprecated
// messages, fields, enums, and enum values.
var deprecationComment = "// Deprecated: Do not use."
// generateService generates all the code for the named service.
func (g *grpc) generateService(file *generator.FileDescriptor, service *pb.ServiceDescriptorProto, index int) {
path := fmt.Sprintf("6,%d", index) // 6 means service.
origServName := service.GetName()
fullServName := origServName
if pkg := file.GetPackage(); pkg != "" {
fullServName = pkg + "." + fullServName
}
servName := generator.CamelCase(origServName)
deprecated := service.GetOptions().GetDeprecated()
g.P()
g.P(fmt.Sprintf(`// %sClient is the client API for %s service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.`, servName, servName))
// Client interface.
if deprecated {
g.P("//")
g.P(deprecationComment)
}
g.P("type ", servName, "Client interface {")
for i, method := range service.Method {
g.gen.PrintComments(fmt.Sprintf("%s,2,%d", path, i)) // 2 means method in a service.
if method.GetOptions().GetDeprecated() {
g.P("//")
g.P(deprecationComment)
}
g.P(g.generateClientSignature(servName, method))
}
g.P("}")
g.P()
// Client structure.
g.P("type ", unexport(servName), "Client struct {")
g.P("cc ", grpcPkg, ".ClientConnInterface")
g.P("}")
g.P()
// NewClient factory.
if deprecated {
g.P(deprecationComment)
}
g.P("func New", servName, "Client (cc ", grpcPkg, ".ClientConnInterface) ", servName, "Client {")
g.P("return &", unexport(servName), "Client{cc}")
g.P("}")
g.P()
var methodIndex, streamIndex int
serviceDescVar := "_" + servName + "_serviceDesc"
// Client method implementations.
for _, method := range service.Method {
var descExpr string
if !method.GetServerStreaming() && !method.GetClientStreaming() {
// Unary RPC method
descExpr = fmt.Sprintf("&%s.Methods[%d]", serviceDescVar, methodIndex)
methodIndex++
} else {
// Streaming RPC method
descExpr = fmt.Sprintf("&%s.Streams[%d]", serviceDescVar, streamIndex)
streamIndex++
}
g.generateClientMethod(servName, fullServName, serviceDescVar, method, descExpr)
}
// Server interface.
serverType := servName + "Server"
g.P("// ", serverType, " is the server API for ", servName, " service.")
if deprecated {
g.P("//")
g.P(deprecationComment)
}
g.P("type ", serverType, " interface {")
for i, method := range service.Method {
g.gen.PrintComments(fmt.Sprintf("%s,2,%d", path, i)) // 2 means method in a service.
if method.GetOptions().GetDeprecated() {
g.P("//")
g.P(deprecationComment)
}
g.P(g.generateServerSignature(servName, method))
}
g.P("}")
g.P()
// Server Unimplemented struct for forward compatibility.
if deprecated {
g.P(deprecationComment)
}
g.generateUnimplementedServer(servName, service)
// Server registration.
if deprecated {
g.P(deprecationComment)
}
g.P("func Register", servName, "Server(s *", grpcPkg, ".Server, srv ", serverType, ") {")
g.P("s.RegisterService(&", serviceDescVar, `, srv)`)
g.P("}")
g.P()
// Server handler implementations.
var handlerNames []string
for _, method := range service.Method {
hname := g.generateServerMethod(servName, fullServName, method)
handlerNames = append(handlerNames, hname)
}
// Service descriptor.
g.P("var ", serviceDescVar, " = ", grpcPkg, ".ServiceDesc {")
g.P("ServiceName: ", strconv.Quote(fullServName), ",")
g.P("HandlerType: (*", serverType, ")(nil),")
g.P("Methods: []", grpcPkg, ".MethodDesc{")
for i, method := range service.Method {
if method.GetServerStreaming() || method.GetClientStreaming() {
continue
}
g.P("{")
g.P("MethodName: ", strconv.Quote(method.GetName()), ",")
g.P("Handler: ", handlerNames[i], ",")
g.P("},")
}
g.P("},")
g.P("Streams: []", grpcPkg, ".StreamDesc{")
for i, method := range service.Method {
if !method.GetServerStreaming() && !method.GetClientStreaming() {
continue
}
g.P("{")
g.P("StreamName: ", strconv.Quote(method.GetName()), ",")
g.P("Handler: ", handlerNames[i], ",")
if method.GetServerStreaming() {
g.P("ServerStreams: true,")
}
if method.GetClientStreaming() {
g.P("ClientStreams: true,")
}
g.P("},")
}
g.P("},")
g.P("Metadata: \"", file.GetName(), "\",")
g.P("}")
g.P()
}
// generateUnimplementedServer creates the unimplemented server struct
func (g *grpc) generateUnimplementedServer(servName string, service *pb.ServiceDescriptorProto) {
serverType := servName + "Server"
g.P("// Unimplemented", serverType, " can be embedded to have forward compatible implementations.")
g.P("type Unimplemented", serverType, " struct {")
g.P("}")
g.P()
// Unimplemented<service_name>Server's concrete methods
for _, method := range service.Method {
g.generateServerMethodConcrete(servName, method)
}
g.P()
}
// generateServerMethodConcrete returns unimplemented methods which ensure forward compatibility
func (g *grpc) generateServerMethodConcrete(servName string, method *pb.MethodDescriptorProto) {
header := g.generateServerSignatureWithParamNames(servName, method)
g.P("func (*Unimplemented", servName, "Server) ", header, " {")
var nilArg string
if !method.GetServerStreaming() && !method.GetClientStreaming() {
nilArg = "nil, "
}
methName := generator.CamelCase(method.GetName())
statusPkg := string(g.gen.AddImport(statusPkgPath))
codePkg := string(g.gen.AddImport(codePkgPath))
g.P("return ", nilArg, statusPkg, `.Errorf(`, codePkg, `.Unimplemented, "method `, methName, ` not implemented")`)
g.P("}")
}
// generateClientSignature returns the client-side signature for a method.
func (g *grpc) generateClientSignature(servName string, method *pb.MethodDescriptorProto) string {
origMethName := method.GetName()
methName := generator.CamelCase(origMethName)
if reservedClientName[methName] {
methName += "_"
}
reqArg := ", in *" + g.typeName(method.GetInputType())
if method.GetClientStreaming() {
reqArg = ""
}
respName := "*" + g.typeName(method.GetOutputType())
if method.GetServerStreaming() || method.GetClientStreaming() {
respName = servName + "_" + generator.CamelCase(origMethName) + "Client"
}
return fmt.Sprintf("%s(ctx %s.Context%s, opts ...%s.CallOption) (%s, error)", methName, contextPkg, reqArg, grpcPkg, respName)
}
func (g *grpc) generateClientMethod(servName, fullServName, serviceDescVar string, method *pb.MethodDescriptorProto, descExpr string) {
sname := fmt.Sprintf("/%s/%s", fullServName, method.GetName())
methName := generator.CamelCase(method.GetName())
inType := g.typeName(method.GetInputType())
outType := g.typeName(method.GetOutputType())
if method.GetOptions().GetDeprecated() {
g.P(deprecationComment)
}
g.P("func (c *", unexport(servName), "Client) ", g.generateClientSignature(servName, method), "{")
if !method.GetServerStreaming() && !method.GetClientStreaming() {
g.P("out := new(", outType, ")")
// TODO: Pass descExpr to Invoke.
g.P(`err := c.cc.Invoke(ctx, "`, sname, `", in, out, opts...)`)
g.P("if err != nil { return nil, err }")
g.P("return out, nil")
g.P("}")
g.P()
return
}
streamType := unexport(servName) + methName + "Client"
g.P("stream, err := c.cc.NewStream(ctx, ", descExpr, `, "`, sname, `", opts...)`)
g.P("if err != nil { return nil, err }")
g.P("x := &", streamType, "{stream}")
if !method.GetClientStreaming() {
g.P("if err := x.ClientStream.SendMsg(in); err != nil { return nil, err }")
g.P("if err := x.ClientStream.CloseSend(); err != nil { return nil, err }")
}
g.P("return x, nil")
g.P("}")
g.P()
genSend := method.GetClientStreaming()
genRecv := method.GetServerStreaming()
genCloseAndRecv := !method.GetServerStreaming()
// Stream auxiliary types and methods.
g.P("type ", servName, "_", methName, "Client interface {")
if genSend {
g.P("Send(*", inType, ") error")
}
if genRecv {
g.P("Recv() (*", outType, ", error)")
}
if genCloseAndRecv {
g.P("CloseAndRecv() (*", outType, ", error)")
}
g.P(grpcPkg, ".ClientStream")
g.P("}")
g.P()
g.P("type ", streamType, " struct {")
g.P(grpcPkg, ".ClientStream")
g.P("}")
g.P()
if genSend {
g.P("func (x *", streamType, ") Send(m *", inType, ") error {")
g.P("return x.ClientStream.SendMsg(m)")
g.P("}")
g.P()
}
if genRecv {
g.P("func (x *", streamType, ") Recv() (*", outType, ", error) {")
g.P("m := new(", outType, ")")
g.P("if err := x.ClientStream.RecvMsg(m); err != nil { return nil, err }")
g.P("return m, nil")
g.P("}")
g.P()
}
if genCloseAndRecv {
g.P("func (x *", streamType, ") CloseAndRecv() (*", outType, ", error) {")
g.P("if err := x.ClientStream.CloseSend(); err != nil { return nil, err }")
g.P("m := new(", outType, ")")
g.P("if err := x.ClientStream.RecvMsg(m); err != nil { return nil, err }")
g.P("return m, nil")
g.P("}")
g.P()
}
}
// generateServerSignatureWithParamNames returns the server-side signature for a method with parameter names.
func (g *grpc) generateServerSignatureWithParamNames(servName string, method *pb.MethodDescriptorProto) string {
origMethName := method.GetName()
methName := generator.CamelCase(origMethName)
if reservedClientName[methName] {
methName += "_"
}
var reqArgs []string
ret := "error"
if !method.GetServerStreaming() && !method.GetClientStreaming() {
reqArgs = append(reqArgs, "ctx "+contextPkg+".Context")
ret = "(*" + g.typeName(method.GetOutputType()) + ", error)"
}
if !method.GetClientStreaming() {
reqArgs = append(reqArgs, "req *"+g.typeName(method.GetInputType()))
}
if method.GetServerStreaming() || method.GetClientStreaming() {
reqArgs = append(reqArgs, "srv "+servName+"_"+generator.CamelCase(origMethName)+"Server")
}
return methName + "(" + strings.Join(reqArgs, ", ") + ") " + ret
}
// generateServerSignature returns the server-side signature for a method.
func (g *grpc) generateServerSignature(servName string, method *pb.MethodDescriptorProto) string {
origMethName := method.GetName()
methName := generator.CamelCase(origMethName)
if reservedClientName[methName] {
methName += "_"
}
var reqArgs []string
ret := "error"
if !method.GetServerStreaming() && !method.GetClientStreaming() {
reqArgs = append(reqArgs, contextPkg+".Context")
ret = "(*" + g.typeName(method.GetOutputType()) + ", error)"
}
if !method.GetClientStreaming() {
reqArgs = append(reqArgs, "*"+g.typeName(method.GetInputType()))
}
if method.GetServerStreaming() || method.GetClientStreaming() {
reqArgs = append(reqArgs, servName+"_"+generator.CamelCase(origMethName)+"Server")
}
return methName + "(" + strings.Join(reqArgs, ", ") + ") " + ret
}
func (g *grpc) generateServerMethod(servName, fullServName string, method *pb.MethodDescriptorProto) string {
methName := generator.CamelCase(method.GetName())
hname := fmt.Sprintf("_%s_%s_Handler", servName, methName)
inType := g.typeName(method.GetInputType())
outType := g.typeName(method.GetOutputType())
if !method.GetServerStreaming() && !method.GetClientStreaming() {
g.P("func ", hname, "(srv interface{}, ctx ", contextPkg, ".Context, dec func(interface{}) error, interceptor ", grpcPkg, ".UnaryServerInterceptor) (interface{}, error) {")
g.P("in := new(", inType, ")")
g.P("if err := dec(in); err != nil { return nil, err }")
g.P("if interceptor == nil { return srv.(", servName, "Server).", methName, "(ctx, in) }")
g.P("info := &", grpcPkg, ".UnaryServerInfo{")
g.P("Server: srv,")
g.P("FullMethod: ", strconv.Quote(fmt.Sprintf("/%s/%s", fullServName, methName)), ",")
g.P("}")
g.P("handler := func(ctx ", contextPkg, ".Context, req interface{}) (interface{}, error) {")
g.P("return srv.(", servName, "Server).", methName, "(ctx, req.(*", inType, "))")
g.P("}")
g.P("return interceptor(ctx, in, info, handler)")
g.P("}")
g.P()
return hname
}
streamType := unexport(servName) + methName + "Server"
g.P("func ", hname, "(srv interface{}, stream ", grpcPkg, ".ServerStream) error {")
if !method.GetClientStreaming() {
g.P("m := new(", inType, ")")
g.P("if err := stream.RecvMsg(m); err != nil { return err }")
g.P("return srv.(", servName, "Server).", methName, "(m, &", streamType, "{stream})")
} else {
g.P("return srv.(", servName, "Server).", methName, "(&", streamType, "{stream})")
}
g.P("}")
g.P()
genSend := method.GetServerStreaming()
genSendAndClose := !method.GetServerStreaming()
genRecv := method.GetClientStreaming()
// Stream auxiliary types and methods.
g.P("type ", servName, "_", methName, "Server interface {")
if genSend {
g.P("Send(*", outType, ") error")
}
if genSendAndClose {
g.P("SendAndClose(*", outType, ") error")
}
if genRecv {
g.P("Recv() (*", inType, ", error)")
}
g.P(grpcPkg, ".ServerStream")
g.P("}")
g.P()
g.P("type ", streamType, " struct {")
g.P(grpcPkg, ".ServerStream")
g.P("}")
g.P()
if genSend {
g.P("func (x *", streamType, ") Send(m *", outType, ") error {")
g.P("return x.ServerStream.SendMsg(m)")
g.P("}")
g.P()
}
if genSendAndClose {
g.P("func (x *", streamType, ") SendAndClose(m *", outType, ") error {")
g.P("return x.ServerStream.SendMsg(m)")
g.P("}")
g.P()
}
if genRecv {
g.P("func (x *", streamType, ") Recv() (*", inType, ", error) {")
g.P("m := new(", inType, ")")
g.P("if err := x.ServerStream.RecvMsg(m); err != nil { return nil, err }")
g.P("return m, nil")
g.P("}")
g.P()
}
return hname
}

34
vendor/github.com/golang/protobuf/protoc-gen-go/link_grpc.go generated vendored
View file

@ -1,34 +0,0 @@
// Go support for Protocol Buffers - Google's data interchange format
//
// Copyright 2015 The Go Authors. All rights reserved.
// https://github.com/golang/protobuf
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
// * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
// * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following disclaimer
// in the documentation and/or other materials provided with the
// distribution.
// * Neither the name of Google Inc. nor the names of its
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
package main
import _ "github.com/golang/protobuf/protoc-gen-go/grpc"

144
vendor/github.com/golang/protobuf/protoc-gen-go/main.go generated vendored
View file

@ -1,98 +1,74 @@
// Go support for Protocol Buffers - Google's data interchange format
//
// Copyright 2010 The Go Authors. All rights reserved.
// https://github.com/golang/protobuf
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
// * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
// * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following disclaimer
// in the documentation and/or other materials provided with the
// distribution.
// * Neither the name of Google Inc. nor the names of its
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
// Copyright 2010 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
// protoc-gen-go is a plugin for the Google protocol buffer compiler to generate
// Go code. Run it by building this program and putting it in your path with
// the name
// protoc-gen-go
// That word 'go' at the end becomes part of the option string set for the
// protocol compiler, so once the protocol compiler (protoc) is installed
// you can run
// protoc --go_out=output_directory input_directory/file.proto
// to generate Go bindings for the protocol defined by file.proto.
// With that input, the output will be written to
// output_directory/file.pb.go
// Go code. Install it by building this program and making it accessible within
// your PATH with the name:
// protoc-gen-go
//
// The generated code is documented in the package comment for
// the library.
// The 'go' suffix becomes part of the argument for the protocol compiler,
// such that it can be invoked as:
// protoc --go_out=paths=source_relative:. path/to/file.proto
//
// This generates Go bindings for the protocol buffer defined by file.proto.
// With that input, the output will be written to:
// path/to/file.pb.go
//
// See the README and documentation for protocol buffers to learn more:
// https://developers.google.com/protocol-buffers/
// https://developers.google.com/protocol-buffers/
package main
import (
"io/ioutil"
"os"
"flag"
"fmt"
"strings"
"github.com/golang/protobuf/proto"
"github.com/golang/protobuf/protoc-gen-go/generator"
"github.com/golang/protobuf/internal/gengogrpc"
gengo "google.golang.org/protobuf/cmd/protoc-gen-go/internal_gengo"
"google.golang.org/protobuf/compiler/protogen"
)
func main() {
// Begin by allocating a generator. The request and response structures are stored there
// so we can do error handling easily - the response structure contains the field to
// report failure.
g := generator.New()
data, err := ioutil.ReadAll(os.Stdin)
if err != nil {
g.Error(err, "reading input")
}
if err := proto.Unmarshal(data, g.Request); err != nil {
g.Error(err, "parsing input proto")
}
if len(g.Request.FileToGenerate) == 0 {
g.Fail("no files to generate")
}
g.CommandLineParameters(g.Request.GetParameter())
// Create a wrapped version of the Descriptors and EnumDescriptors that
// point to the file that defines them.
g.WrapTypes()
g.SetPackageNames()
g.BuildTypeNameMap()
g.GenerateAllFiles()
// Send back the results.
data, err = proto.Marshal(g.Response)
if err != nil {
g.Error(err, "failed to marshal output proto")
}
_, err = os.Stdout.Write(data)
if err != nil {
g.Error(err, "failed to write output proto")
var (
flags flag.FlagSet
plugins = flags.String("plugins", "", "list of plugins to enable (supported values: grpc)")
importPrefix = flags.String("import_prefix", "", "prefix to prepend to import paths")
)
importRewriteFunc := func(importPath protogen.GoImportPath) protogen.GoImportPath {
switch importPath {
case "context", "fmt", "math":
return importPath
}
if *importPrefix != "" {
return protogen.GoImportPath(*importPrefix) + importPath
}
return importPath
}
protogen.Options{
ParamFunc: flags.Set,
ImportRewriteFunc: importRewriteFunc,
}.Run(func(gen *protogen.Plugin) error {
grpc := false
for _, plugin := range strings.Split(*plugins, ",") {
switch plugin {
case "grpc":
grpc = true
case "":
default:
return fmt.Errorf("protoc-gen-go: unknown plugin %q", plugin)
}
}
for _, f := range gen.Files {
if !f.Generate {
continue
}
g := gengo.GenerateFile(gen, f)
if grpc {
gengogrpc.GenerateFileContent(gen, f, g)
}
}
gen.SupportedFeatures = gengo.SupportedFeatures
return nil
})
}

369
vendor/github.com/golang/protobuf/protoc-gen-go/plugin/plugin.pb.go generated vendored
View file

@ -1,369 +0,0 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
// source: google/protobuf/compiler/plugin.proto
/*
Package plugin_go is a generated protocol buffer package.
It is generated from these files:
google/protobuf/compiler/plugin.proto
It has these top-level messages:
Version
CodeGeneratorRequest
CodeGeneratorResponse
*/
package plugin_go
import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
import google_protobuf "github.com/golang/protobuf/protoc-gen-go/descriptor"
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf
// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
// The version number of protocol compiler.
type Version struct {
Major *int32 `protobuf:"varint,1,opt,name=major" json:"major,omitempty"`
Minor *int32 `protobuf:"varint,2,opt,name=minor" json:"minor,omitempty"`
Patch *int32 `protobuf:"varint,3,opt,name=patch" json:"patch,omitempty"`
// A suffix for alpha, beta or rc release, e.g., "alpha-1", "rc2". It should
// be empty for mainline stable releases.
Suffix *string `protobuf:"bytes,4,opt,name=suffix" json:"suffix,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *Version) Reset() { *m = Version{} }
func (m *Version) String() string { return proto.CompactTextString(m) }
func (*Version) ProtoMessage() {}
func (*Version) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{0} }
func (m *Version) Unmarshal(b []byte) error {
return xxx_messageInfo_Version.Unmarshal(m, b)
}
func (m *Version) Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_Version.Marshal(b, m, deterministic)
}
func (dst *Version) XXX_Merge(src proto.Message) {
xxx_messageInfo_Version.Merge(dst, src)
}
func (m *Version) XXX_Size() int {
return xxx_messageInfo_Version.Size(m)
}
func (m *Version) XXX_DiscardUnknown() {
xxx_messageInfo_Version.DiscardUnknown(m)
}
var xxx_messageInfo_Version proto.InternalMessageInfo
func (m *Version) GetMajor() int32 {
if m != nil && m.Major != nil {
return *m.Major
}
return 0
}
func (m *Version) GetMinor() int32 {
if m != nil && m.Minor != nil {
return *m.Minor
}
return 0
}
func (m *Version) GetPatch() int32 {
if m != nil && m.Patch != nil {
return *m.Patch
}
return 0
}
func (m *Version) GetSuffix() string {
if m != nil && m.Suffix != nil {
return *m.Suffix
}
return ""
}
// An encoded CodeGeneratorRequest is written to the plugin's stdin.
type CodeGeneratorRequest struct {
// The .proto files that were explicitly listed on the command-line. The
// code generator should generate code only for these files. Each file's
// descriptor will be included in proto_file, below.
FileToGenerate []string `protobuf:"bytes,1,rep,name=file_to_generate,json=fileToGenerate" json:"file_to_generate,omitempty"`
// The generator parameter passed on the command-line.
Parameter *string `protobuf:"bytes,2,opt,name=parameter" json:"parameter,omitempty"`
// FileDescriptorProtos for all files in files_to_generate and everything
// they import. The files will appear in topological order, so each file
// appears before any file that imports it.
//
// protoc guarantees that all proto_files will be written after
// the fields above, even though this is not technically guaranteed by the
// protobuf wire format. This theoretically could allow a plugin to stream
// in the FileDescriptorProtos and handle them one by one rather than read
// the entire set into memory at once. However, as of this writing, this
// is not similarly optimized on protoc's end -- it will store all fields in
// memory at once before sending them to the plugin.
//
// Type names of fields and extensions in the FileDescriptorProto are always
// fully qualified.
ProtoFile []*google_protobuf.FileDescriptorProto `protobuf:"bytes,15,rep,name=proto_file,json=protoFile" json:"proto_file,omitempty"`
// The version number of protocol compiler.
CompilerVersion *Version `protobuf:"bytes,3,opt,name=compiler_version,json=compilerVersion" json:"compiler_version,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *CodeGeneratorRequest) Reset() { *m = CodeGeneratorRequest{} }
func (m *CodeGeneratorRequest) String() string { return proto.CompactTextString(m) }
func (*CodeGeneratorRequest) ProtoMessage() {}
func (*CodeGeneratorRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{1} }
func (m *CodeGeneratorRequest) Unmarshal(b []byte) error {
return xxx_messageInfo_CodeGeneratorRequest.Unmarshal(m, b)
}
func (m *CodeGeneratorRequest) Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_CodeGeneratorRequest.Marshal(b, m, deterministic)
}
func (dst *CodeGeneratorRequest) XXX_Merge(src proto.Message) {
xxx_messageInfo_CodeGeneratorRequest.Merge(dst, src)
}
func (m *CodeGeneratorRequest) XXX_Size() int {
return xxx_messageInfo_CodeGeneratorRequest.Size(m)
}
func (m *CodeGeneratorRequest) XXX_DiscardUnknown() {
xxx_messageInfo_CodeGeneratorRequest.DiscardUnknown(m)
}
var xxx_messageInfo_CodeGeneratorRequest proto.InternalMessageInfo
func (m *CodeGeneratorRequest) GetFileToGenerate() []string {
if m != nil {
return m.FileToGenerate
}
return nil
}
func (m *CodeGeneratorRequest) GetParameter() string {
if m != nil && m.Parameter != nil {
return *m.Parameter
}
return ""
}
func (m *CodeGeneratorRequest) GetProtoFile() []*google_protobuf.FileDescriptorProto {
if m != nil {
return m.ProtoFile
}
return nil
}
func (m *CodeGeneratorRequest) GetCompilerVersion() *Version {
if m != nil {
return m.CompilerVersion
}
return nil
}
// The plugin writes an encoded CodeGeneratorResponse to stdout.
type CodeGeneratorResponse struct {
// Error message. If non-empty, code generation failed. The plugin process
// should exit with status code zero even if it reports an error in this way.
//
// This should be used to indicate errors in .proto files which prevent the
// code generator from generating correct code. Errors which indicate a
// problem in protoc itself -- such as the input CodeGeneratorRequest being
// unparseable -- should be reported by writing a message to stderr and
// exiting with a non-zero status code.
Error *string `protobuf:"bytes,1,opt,name=error" json:"error,omitempty"`
File []*CodeGeneratorResponse_File `protobuf:"bytes,15,rep,name=file" json:"file,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *CodeGeneratorResponse) Reset() { *m = CodeGeneratorResponse{} }
func (m *CodeGeneratorResponse) String() string { return proto.CompactTextString(m) }
func (*CodeGeneratorResponse) ProtoMessage() {}
func (*CodeGeneratorResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{2} }
func (m *CodeGeneratorResponse) Unmarshal(b []byte) error {
return xxx_messageInfo_CodeGeneratorResponse.Unmarshal(m, b)
}
func (m *CodeGeneratorResponse) Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_CodeGeneratorResponse.Marshal(b, m, deterministic)
}
func (dst *CodeGeneratorResponse) XXX_Merge(src proto.Message) {
xxx_messageInfo_CodeGeneratorResponse.Merge(dst, src)
}
func (m *CodeGeneratorResponse) XXX_Size() int {
return xxx_messageInfo_CodeGeneratorResponse.Size(m)
}
func (m *CodeGeneratorResponse) XXX_DiscardUnknown() {
xxx_messageInfo_CodeGeneratorResponse.DiscardUnknown(m)
}
var xxx_messageInfo_CodeGeneratorResponse proto.InternalMessageInfo
func (m *CodeGeneratorResponse) GetError() string {
if m != nil && m.Error != nil {
return *m.Error
}
return ""
}
func (m *CodeGeneratorResponse) GetFile() []*CodeGeneratorResponse_File {
if m != nil {
return m.File
}
return nil
}
// Represents a single generated file.
type CodeGeneratorResponse_File struct {
// The file name, relative to the output directory. The name must not
// contain "." or ".." components and must be relative, not be absolute (so,
// the file cannot lie outside the output directory). "/" must be used as
// the path separator, not "\".
//
// If the name is omitted, the content will be appended to the previous
// file. This allows the generator to break large files into small chunks,
// and allows the generated text to be streamed back to protoc so that large
// files need not reside completely in memory at one time. Note that as of
// this writing protoc does not optimize for this -- it will read the entire
// CodeGeneratorResponse before writing files to disk.
Name *string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
// If non-empty, indicates that the named file should already exist, and the
// content here is to be inserted into that file at a defined insertion
// point. This feature allows a code generator to extend the output
// produced by another code generator. The original generator may provide
// insertion points by placing special annotations in the file that look
// like:
// @@protoc_insertion_point(NAME)
// The annotation can have arbitrary text before and after it on the line,
// which allows it to be placed in a comment. NAME should be replaced with
// an identifier naming the point -- this is what other generators will use
// as the insertion_point. Code inserted at this point will be placed
// immediately above the line containing the insertion point (thus multiple
// insertions to the same point will come out in the order they were added).
// The double-@ is intended to make it unlikely that the generated code
// could contain things that look like insertion points by accident.
//
// For example, the C++ code generator places the following line in the
// .pb.h files that it generates:
// // @@protoc_insertion_point(namespace_scope)
// This line appears within the scope of the file's package namespace, but
// outside of any particular class. Another plugin can then specify the
// insertion_point "namespace_scope" to generate additional classes or
// other declarations that should be placed in this scope.
//
// Note that if the line containing the insertion point begins with
// whitespace, the same whitespace will be added to every line of the
// inserted text. This is useful for languages like Python, where
// indentation matters. In these languages, the insertion point comment
// should be indented the same amount as any inserted code will need to be
// in order to work correctly in that context.
//
// The code generator that generates the initial file and the one which
// inserts into it must both run as part of a single invocation of protoc.
// Code generators are executed in the order in which they appear on the
// command line.
//
// If |insertion_point| is present, |name| must also be present.
InsertionPoint *string `protobuf:"bytes,2,opt,name=insertion_point,json=insertionPoint" json:"insertion_point,omitempty"`
// The file contents.
Content *string `protobuf:"bytes,15,opt,name=content" json:"content,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *CodeGeneratorResponse_File) Reset() { *m = CodeGeneratorResponse_File{} }
func (m *CodeGeneratorResponse_File) String() string { return proto.CompactTextString(m) }
func (*CodeGeneratorResponse_File) ProtoMessage() {}
func (*CodeGeneratorResponse_File) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{2, 0} }
func (m *CodeGeneratorResponse_File) Unmarshal(b []byte) error {
return xxx_messageInfo_CodeGeneratorResponse_File.Unmarshal(m, b)
}
func (m *CodeGeneratorResponse_File) Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_CodeGeneratorResponse_File.Marshal(b, m, deterministic)
}
func (dst *CodeGeneratorResponse_File) XXX_Merge(src proto.Message) {
xxx_messageInfo_CodeGeneratorResponse_File.Merge(dst, src)
}
func (m *CodeGeneratorResponse_File) XXX_Size() int {
return xxx_messageInfo_CodeGeneratorResponse_File.Size(m)
}
func (m *CodeGeneratorResponse_File) XXX_DiscardUnknown() {
xxx_messageInfo_CodeGeneratorResponse_File.DiscardUnknown(m)
}
var xxx_messageInfo_CodeGeneratorResponse_File proto.InternalMessageInfo
func (m *CodeGeneratorResponse_File) GetName() string {
if m != nil && m.Name != nil {
return *m.Name
}
return ""
}
func (m *CodeGeneratorResponse_File) GetInsertionPoint() string {
if m != nil && m.InsertionPoint != nil {
return *m.InsertionPoint
}
return ""
}
func (m *CodeGeneratorResponse_File) GetContent() string {
if m != nil && m.Content != nil {
return *m.Content
}
return ""
}
func init() {
proto.RegisterType((*Version)(nil), "google.protobuf.compiler.Version")
proto.RegisterType((*CodeGeneratorRequest)(nil), "google.protobuf.compiler.CodeGeneratorRequest")
proto.RegisterType((*CodeGeneratorResponse)(nil), "google.protobuf.compiler.CodeGeneratorResponse")
proto.RegisterType((*CodeGeneratorResponse_File)(nil), "google.protobuf.compiler.CodeGeneratorResponse.File")
}
func init() { proto.RegisterFile("google/protobuf/compiler/plugin.proto", fileDescriptor0) }
var fileDescriptor0 = []byte{
// 417 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x74, 0x92, 0xcf, 0x6a, 0x14, 0x41,
0x10, 0xc6, 0x19, 0x77, 0x63, 0x98, 0x8a, 0x64, 0x43, 0x13, 0xa5, 0x09, 0x39, 0x8c, 0x8b, 0xe2,
0x5c, 0x32, 0x0b, 0xc1, 0x8b, 0x78, 0x4b, 0x44, 0x3d, 0x78, 0x58, 0x1a, 0xf1, 0x20, 0xc8, 0x30,
0x99, 0xd4, 0x74, 0x5a, 0x66, 0xba, 0xc6, 0xee, 0x1e, 0xf1, 0x49, 0x7d, 0x0f, 0xdf, 0x40, 0xfa,
0xcf, 0x24, 0xb2, 0xb8, 0xa7, 0xee, 0xef, 0x57, 0xd5, 0xd5, 0x55, 0x1f, 0x05, 0x2f, 0x25, 0x91,
0xec, 0x71, 0x33, 0x1a, 0x72, 0x74, 0x33, 0x75, 0x9b, 0x96, 0x86, 0x51, 0xf5, 0x68, 0x36, 0x63,
0x3f, 0x49, 0xa5, 0xab, 0x10, 0x60, 0x3c, 0xa6, 0x55, 0x73, 0x5a, 0x35, 0xa7, 0x9d, 0x15, 0xbb,
0x05, 0x6e, 0xd1, 0xb6, 0x46, 0x8d, 0x8e, 0x4c, 0xcc, 0x5e, 0xb7, 0x70, 0xf8, 0x05, 0x8d, 0x55,
0xa4, 0xd9, 0x29, 0x1c, 0x0c, 0xcd, 0x77, 0x32, 0x3c, 0x2b, 0xb2, 0xf2, 0x40, 0x44, 0x11, 0xa8,
0xd2, 0x64, 0xf8, 0xa3, 0x44, 0xbd, 0xf0, 0x74, 0x6c, 0x5c, 0x7b, 0xc7, 0x17, 0x91, 0x06, 0xc1,
0x9e, 0xc1, 0x63, 0x3b, 0x75, 0x9d, 0xfa, 0xc5, 0x97, 0x45, 0x56, 0xe6, 0x22, 0xa9, 0xf5, 0x9f,
0x0c, 0x4e, 0xaf, 0xe9, 0x16, 0x3f, 0xa0, 0x46, 0xd3, 0x38, 0x32, 0x02, 0x7f, 0x4c, 0x68, 0x1d,
0x2b, 0xe1, 0xa4, 0x53, 0x3d, 0xd6, 0x8e, 0x6a, 0x19, 0x63, 0xc8, 0xb3, 0x62, 0x51, 0xe6, 0xe2,
0xd8, 0xf3, 0xcf, 0x94, 0x5e, 0x20, 0x3b, 0x87, 0x7c, 0x6c, 0x4c, 0x33, 0xa0, 0xc3, 0xd8, 0x4a,
0x2e, 0x1e, 0x00, 0xbb, 0x06, 0x08, 0xe3, 0xd4, 0xfe, 0x15, 0x5f, 0x15, 0x8b, 0xf2, 0xe8, 0xf2,
0x45, 0xb5, 0x6b, 0xcb, 0x7b, 0xd5, 0xe3, 0xbb, 0x7b, 0x03, 0xb6, 0x1e, 0x8b, 0x3c, 0x44, 0x7d,
0x84, 0x7d, 0x82, 0x93, 0xd9, 0xb8, 0xfa, 0x67, 0xf4, 0x24, 0x8c, 0x77, 0x74, 0xf9, 0xbc, 0xda,
0xe7, 0x70, 0x95, 0xcc, 0x13, 0xab, 0x99, 0x24, 0xb0, 0xfe, 0x9d, 0xc1, 0xd3, 0x9d, 0x99, 0xed,
0x48, 0xda, 0xa2, 0xf7, 0x0e, 0x8d, 0x49, 0x3e, 0xe7, 0x22, 0x0a, 0xf6, 0x11, 0x96, 0xff, 0x34,
0xff, 0x7a, 0xff, 0x8f, 0xff, 0x2d, 0x1a, 0x66, 0x13, 0xa1, 0xc2, 0xd9, 0x37, 0x58, 0x86, 0x79,
0x18, 0x2c, 0x75, 0x33, 0x60, 0xfa, 0x26, 0xdc, 0xd9, 0x2b, 0x58, 0x29, 0x6d, 0xd1, 0x38, 0x45,
0xba, 0x1e, 0x49, 0x69, 0x97, 0xcc, 0x3c, 0xbe, 0xc7, 0x5b, 0x4f, 0x19, 0x87, 0xc3, 0x96, 0xb4,
0x43, 0xed, 0xf8, 0x2a, 0x24, 0xcc, 0xf2, 0x4a, 0xc2, 0x79, 0x4b, 0xc3, 0xde, 0xfe, 0xae, 0x9e,
0x6c, 0xc3, 0x6e, 0x06, 0x7b, 0xed, 0xd7, 0x37, 0x52, 0xb9, 0xbb, 0xe9, 0xc6, 0x87, 0x37, 0x92,
0xfa, 0x46, 0xcb, 0x87, 0x65, 0x0c, 0x97, 0xf6, 0x42, 0xa2, 0xbe, 0x90, 0x94, 0x56, 0xfa, 0x6d,
0x3c, 0x6a, 0x49, 0x7f, 0x03, 0x00, 0x00, 0xff, 0xff, 0xf7, 0x15, 0x40, 0xc5, 0xfe, 0x02, 0x00,
0x00,
}

83
vendor/github.com/golang/protobuf/protoc-gen-go/plugin/plugin.pb.golden generated vendored
View file

@ -1,83 +0,0 @@
// Code generated by protoc-gen-go.
// source: google/protobuf/compiler/plugin.proto
// DO NOT EDIT!
package google_protobuf_compiler
import proto "github.com/golang/protobuf/proto"
import "math"
import google_protobuf "github.com/golang/protobuf/protoc-gen-go/descriptor"
// Reference proto and math imports to suppress error if they are not otherwise used.
var _ = proto.GetString
var _ = math.Inf
type CodeGeneratorRequest struct {
FileToGenerate []string `protobuf:"bytes,1,rep,name=file_to_generate" json:"file_to_generate,omitempty"`
Parameter *string `protobuf:"bytes,2,opt,name=parameter" json:"parameter,omitempty"`
ProtoFile []*google_protobuf.FileDescriptorProto `protobuf:"bytes,15,rep,name=proto_file" json:"proto_file,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (this *CodeGeneratorRequest) Reset() { *this = CodeGeneratorRequest{} }
func (this *CodeGeneratorRequest) String() string { return proto.CompactTextString(this) }
func (*CodeGeneratorRequest) ProtoMessage() {}
func (this *CodeGeneratorRequest) GetParameter() string {
if this != nil && this.Parameter != nil {
return *this.Parameter
}
return ""
}
type CodeGeneratorResponse struct {
Error *string `protobuf:"bytes,1,opt,name=error" json:"error,omitempty"`
File []*CodeGeneratorResponse_File `protobuf:"bytes,15,rep,name=file" json:"file,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (this *CodeGeneratorResponse) Reset() { *this = CodeGeneratorResponse{} }
func (this *CodeGeneratorResponse) String() string { return proto.CompactTextString(this) }
func (*CodeGeneratorResponse) ProtoMessage() {}
func (this *CodeGeneratorResponse) GetError() string {
if this != nil && this.Error != nil {
return *this.Error
}
return ""
}
type CodeGeneratorResponse_File struct {
Name *string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
InsertionPoint *string `protobuf:"bytes,2,opt,name=insertion_point" json:"insertion_point,omitempty"`
Content *string `protobuf:"bytes,15,opt,name=content" json:"content,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (this *CodeGeneratorResponse_File) Reset() { *this = CodeGeneratorResponse_File{} }
func (this *CodeGeneratorResponse_File) String() string { return proto.CompactTextString(this) }
func (*CodeGeneratorResponse_File) ProtoMessage() {}
func (this *CodeGeneratorResponse_File) GetName() string {
if this != nil && this.Name != nil {
return *this.Name
}
return ""
}
func (this *CodeGeneratorResponse_File) GetInsertionPoint() string {
if this != nil && this.InsertionPoint != nil {
return *this.InsertionPoint
}
return ""
}
func (this *CodeGeneratorResponse_File) GetContent() string {
if this != nil && this.Content != nil {
return *this.Content
}
return ""
}
func init() {
}

167
vendor/github.com/golang/protobuf/protoc-gen-go/plugin/plugin.proto generated vendored
View file

@ -1,167 +0,0 @@
// Protocol Buffers - Google's data interchange format
// Copyright 2008 Google Inc. All rights reserved.
// https://developers.google.com/protocol-buffers/
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
// * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
// * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following disclaimer
// in the documentation and/or other materials provided with the
// distribution.
// * Neither the name of Google Inc. nor the names of its
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
// Author: kenton@google.com (Kenton Varda)
//
// WARNING: The plugin interface is currently EXPERIMENTAL and is subject to
// change.
//
// protoc (aka the Protocol Compiler) can be extended via plugins. A plugin is
// just a program that reads a CodeGeneratorRequest from stdin and writes a
// CodeGeneratorResponse to stdout.
//
// Plugins written using C++ can use google/protobuf/compiler/plugin.h instead
// of dealing with the raw protocol defined here.
//
// A plugin executable needs only to be placed somewhere in the path. The
// plugin should be named "protoc-gen-$NAME", and will then be used when the
// flag "--${NAME}_out" is passed to protoc.
syntax = "proto2";
package google.protobuf.compiler;
option java_package = "com.google.protobuf.compiler";
option java_outer_classname = "PluginProtos";
option go_package = "github.com/golang/protobuf/protoc-gen-go/plugin;plugin_go";
import "google/protobuf/descriptor.proto";
// The version number of protocol compiler.
message Version {
optional int32 major = 1;
optional int32 minor = 2;
optional int32 patch = 3;
// A suffix for alpha, beta or rc release, e.g., "alpha-1", "rc2". It should
// be empty for mainline stable releases.
optional string suffix = 4;
}
// An encoded CodeGeneratorRequest is written to the plugin's stdin.
message CodeGeneratorRequest {
// The .proto files that were explicitly listed on the command-line. The
// code generator should generate code only for these files. Each file's
// descriptor will be included in proto_file, below.
repeated string file_to_generate = 1;
// The generator parameter passed on the command-line.
optional string parameter = 2;
// FileDescriptorProtos for all files in files_to_generate and everything
// they import. The files will appear in topological order, so each file
// appears before any file that imports it.
//
// protoc guarantees that all proto_files will be written after
// the fields above, even though this is not technically guaranteed by the
// protobuf wire format. This theoretically could allow a plugin to stream
// in the FileDescriptorProtos and handle them one by one rather than read
// the entire set into memory at once. However, as of this writing, this
// is not similarly optimized on protoc's end -- it will store all fields in
// memory at once before sending them to the plugin.
//
// Type names of fields and extensions in the FileDescriptorProto are always
// fully qualified.
repeated FileDescriptorProto proto_file = 15;
// The version number of protocol compiler.
optional Version compiler_version = 3;
}
// The plugin writes an encoded CodeGeneratorResponse to stdout.
message CodeGeneratorResponse {
// Error message. If non-empty, code generation failed. The plugin process
// should exit with status code zero even if it reports an error in this way.
//
// This should be used to indicate errors in .proto files which prevent the
// code generator from generating correct code. Errors which indicate a
// problem in protoc itself -- such as the input CodeGeneratorRequest being
// unparseable -- should be reported by writing a message to stderr and
// exiting with a non-zero status code.
optional string error = 1;
// Represents a single generated file.
message File {
// The file name, relative to the output directory. The name must not
// contain "." or ".." components and must be relative, not be absolute (so,
// the file cannot lie outside the output directory). "/" must be used as
// the path separator, not "\".
//
// If the name is omitted, the content will be appended to the previous
// file. This allows the generator to break large files into small chunks,
// and allows the generated text to be streamed back to protoc so that large
// files need not reside completely in memory at one time. Note that as of
// this writing protoc does not optimize for this -- it will read the entire
// CodeGeneratorResponse before writing files to disk.
optional string name = 1;
// If non-empty, indicates that the named file should already exist, and the
// content here is to be inserted into that file at a defined insertion
// point. This feature allows a code generator to extend the output
// produced by another code generator. The original generator may provide
// insertion points by placing special annotations in the file that look
// like:
// @@protoc_insertion_point(NAME)
// The annotation can have arbitrary text before and after it on the line,
// which allows it to be placed in a comment. NAME should be replaced with
// an identifier naming the point -- this is what other generators will use
// as the insertion_point. Code inserted at this point will be placed
// immediately above the line containing the insertion point (thus multiple
// insertions to the same point will come out in the order they were added).
// The double-@ is intended to make it unlikely that the generated code
// could contain things that look like insertion points by accident.
//
// For example, the C++ code generator places the following line in the
// .pb.h files that it generates:
// // @@protoc_insertion_point(namespace_scope)
// This line appears within the scope of the file's package namespace, but
// outside of any particular class. Another plugin can then specify the
// insertion_point "namespace_scope" to generate additional classes or
// other declarations that should be placed in this scope.
//
// Note that if the line containing the insertion point begins with
// whitespace, the same whitespace will be added to every line of the
// inserted text. This is useful for languages like Python, where
// indentation matters. In these languages, the insertion point comment
// should be indented the same amount as any inserted code will need to be
// in order to work correctly in that context.
//
// The code generator that generates the initial file and the one which
// inserts into it must both run as part of a single invocation of protoc.
// Code generators are executed in the order in which they appear on the
// command line.
//
// If |insertion_point| is present, |name| must also be present.
optional string insertion_point = 2;
// The file contents.
optional string content = 15;
}
repeated File file = 15;
}

214
vendor/github.com/golang/protobuf/ptypes/any.go generated vendored
View file

@ -1,141 +1,165 @@
// Go support for Protocol Buffers - Google's data interchange format
//
// Copyright 2016 The Go Authors. All rights reserved.
// https://github.com/golang/protobuf
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
// * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
// * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following disclaimer
// in the documentation and/or other materials provided with the
// distribution.
// * Neither the name of Google Inc. nor the names of its
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
// Copyright 2016 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
package ptypes
// This file implements functions to marshal proto.Message to/from
// google.protobuf.Any message.
import (
"fmt"
"reflect"
"strings"
"github.com/golang/protobuf/proto"
"github.com/golang/protobuf/ptypes/any"
"google.golang.org/protobuf/reflect/protoreflect"
"google.golang.org/protobuf/reflect/protoregistry"
anypb "github.com/golang/protobuf/ptypes/any"
)
const googleApis = "type.googleapis.com/"
const urlPrefix = "type.googleapis.com/"
// AnyMessageName returns the name of the message contained in a google.protobuf.Any message.
//
// Note that regular type assertions should be done using the Is
// function. AnyMessageName is provided for less common use cases like filtering a
// sequence of Any messages based on a set of allowed message type names.
func AnyMessageName(any *any.Any) (string, error) {
// AnyMessageName returns the message name contained in an anypb.Any message.
// Most type assertions should use the Is function instead.
func AnyMessageName(any *anypb.Any) (string, error) {
name, err := anyMessageName(any)
return string(name), err
}
func anyMessageName(any *anypb.Any) (protoreflect.FullName, error) {
if any == nil {
return "", fmt.Errorf("message is nil")
}
slash := strings.LastIndex(any.TypeUrl, "/")
if slash < 0 {
name := protoreflect.FullName(any.TypeUrl)
if i := strings.LastIndex(any.TypeUrl, "/"); i >= 0 {
name = name[i+len("/"):]
}
if !name.IsValid() {
return "", fmt.Errorf("message type url %q is invalid", any.TypeUrl)
}
return any.TypeUrl[slash+1:], nil
return name, nil
}
// MarshalAny takes the protocol buffer and encodes it into google.protobuf.Any.
func MarshalAny(pb proto.Message) (*any.Any, error) {
value, err := proto.Marshal(pb)
// MarshalAny marshals the given message m into an anypb.Any message.
func MarshalAny(m proto.Message) (*anypb.Any, error) {
switch dm := m.(type) {
case DynamicAny:
m = dm.Message
case *DynamicAny:
if dm == nil {
return nil, proto.ErrNil
}
m = dm.Message
}
b, err := proto.Marshal(m)
if err != nil {
return nil, err
}
return &any.Any{TypeUrl: googleApis + proto.MessageName(pb), Value: value}, nil
return &anypb.Any{TypeUrl: urlPrefix + proto.MessageName(m), Value: b}, nil
}
// DynamicAny is a value that can be passed to UnmarshalAny to automatically
// allocate a proto.Message for the type specified in a google.protobuf.Any
// message. The allocated message is stored in the embedded proto.Message.
//
// Example:
//
// var x ptypes.DynamicAny
// if err := ptypes.UnmarshalAny(a, &x); err != nil { ... }
// fmt.Printf("unmarshaled message: %v", x.Message)
type DynamicAny struct {
proto.Message
}
// Empty returns a new proto.Message of the type specified in a
// google.protobuf.Any message. It returns an error if corresponding message
// type isn't linked in.
func Empty(any *any.Any) (proto.Message, error) {
aname, err := AnyMessageName(any)
// Empty returns a new message of the type specified in an anypb.Any message.
// It returns protoregistry.NotFound if the corresponding message type could not
// be resolved in the global registry.
func Empty(any *anypb.Any) (proto.Message, error) {
name, err := anyMessageName(any)
if err != nil {
return nil, err
}
t := proto.MessageType(aname)
if t == nil {
return nil, fmt.Errorf("any: message type %q isn't linked in", aname)
mt, err := protoregistry.GlobalTypes.FindMessageByName(name)
if err != nil {
return nil, err
}
return reflect.New(t.Elem()).Interface().(proto.Message), nil
return proto.MessageV1(mt.New().Interface()), nil
}
// UnmarshalAny parses the protocol buffer representation in a google.protobuf.Any
// message and places the decoded result in pb. It returns an error if type of
// contents of Any message does not match type of pb message.
// UnmarshalAny unmarshals the encoded value contained in the anypb.Any message
// into the provided message m. It returns an error if the target message
// does not match the type in the Any message or if an unmarshal error occurs.
//
// pb can be a proto.Message, or a *DynamicAny.
func UnmarshalAny(any *any.Any, pb proto.Message) error {
if d, ok := pb.(*DynamicAny); ok {
if d.Message == nil {
// The target message m may be a *DynamicAny message. If the underlying message
// type could not be resolved, then this returns protoregistry.NotFound.
func UnmarshalAny(any *anypb.Any, m proto.Message) error {
if dm, ok := m.(*DynamicAny); ok {
if dm.Message == nil {
var err error
d.Message, err = Empty(any)
dm.Message, err = Empty(any)
if err != nil {
return err
}
}
return UnmarshalAny(any, d.Message)
m = dm.Message
}
aname, err := AnyMessageName(any)
anyName, err := AnyMessageName(any)
if err != nil {
return err
}
mname := proto.MessageName(pb)
if aname != mname {
return fmt.Errorf("mismatched message type: got %q want %q", aname, mname)
msgName := proto.MessageName(m)
if anyName != msgName {
return fmt.Errorf("mismatched message type: got %q want %q", anyName, msgName)
}
return proto.Unmarshal(any.Value, pb)
return proto.Unmarshal(any.Value, m)
}
// Is returns true if any value contains a given message type.
func Is(any *any.Any, pb proto.Message) bool {
// The following is equivalent to AnyMessageName(any) == proto.MessageName(pb),
// but it avoids scanning TypeUrl for the slash.
if any == nil {
// Is reports whether the Any message contains a message of the specified type.
func Is(any *anypb.Any, m proto.Message) bool {
if any == nil || m == nil {
return false
}
name := proto.MessageName(pb)
prefix := len(any.TypeUrl) - len(name)
return prefix >= 1 && any.TypeUrl[prefix-1] == '/' && any.TypeUrl[prefix:] == name
name := proto.MessageName(m)
if !strings.HasSuffix(any.TypeUrl, name) {
return false
}
return len(any.TypeUrl) == len(name) || any.TypeUrl[len(any.TypeUrl)-len(name)-1] == '/'
}
// DynamicAny is a value that can be passed to UnmarshalAny to automatically
// allocate a proto.Message for the type specified in an anypb.Any message.
// The allocated message is stored in the embedded proto.Message.
//
// Example:
// var x ptypes.DynamicAny
// if err := ptypes.UnmarshalAny(a, &x); err != nil { ... }
// fmt.Printf("unmarshaled message: %v", x.Message)
type DynamicAny struct{ proto.Message }
func (m DynamicAny) String() string {
if m.Message == nil {
return "<nil>"
}
return m.Message.String()
}
func (m DynamicAny) Reset() {
if m.Message == nil {
return
}
m.Message.Reset()
}
func (m DynamicAny) ProtoMessage() {
return
}
func (m DynamicAny) ProtoReflect() protoreflect.Message {
if m.Message == nil {
return nil
}
return dynamicAny{proto.MessageReflect(m.Message)}
}
type dynamicAny struct{ protoreflect.Message }
func (m dynamicAny) Type() protoreflect.MessageType {
return dynamicAnyType{m.Message.Type()}
}
func (m dynamicAny) New() protoreflect.Message {
return dynamicAnyType{m.Message.Type()}.New()
}
func (m dynamicAny) Interface() protoreflect.ProtoMessage {
return DynamicAny{proto.MessageV1(m.Message.Interface())}
}
type dynamicAnyType struct{ protoreflect.MessageType }
func (t dynamicAnyType) New() protoreflect.Message {
return dynamicAny{t.MessageType.New()}
}
func (t dynamicAnyType) Zero() protoreflect.Message {
return dynamicAny{t.MessageType.Zero()}
}

235
vendor/github.com/golang/protobuf/ptypes/any/any.pb.go generated vendored
View file

@ -1,203 +1,62 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
// source: google/protobuf/any.proto
// source: github.com/golang/protobuf/ptypes/any/any.proto
package any
import (
fmt "fmt"
proto "github.com/golang/protobuf/proto"
math "math"
protoreflect "google.golang.org/protobuf/reflect/protoreflect"
protoimpl "google.golang.org/protobuf/runtime/protoimpl"
anypb "google.golang.org/protobuf/types/known/anypb"
reflect "reflect"
)
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf
// Symbols defined in public import of google/protobuf/any.proto.
// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.ProtoPackageIsVersion3 // please upgrade the proto package
type Any = anypb.Any
// `Any` contains an arbitrary serialized protocol buffer message along with a
// URL that describes the type of the serialized message.
//
// Protobuf library provides support to pack/unpack Any values in the form
// of utility functions or additional generated methods of the Any type.
//
// Example 1: Pack and unpack a message in C++.
//
// Foo foo = ...;
// Any any;
// any.PackFrom(foo);
// ...
// if (any.UnpackTo(&foo)) {
// ...
// }
//
// Example 2: Pack and unpack a message in Java.
//
// Foo foo = ...;
// Any any = Any.pack(foo);
// ...
// if (any.is(Foo.class)) {
// foo = any.unpack(Foo.class);
// }
//
// Example 3: Pack and unpack a message in Python.
//
// foo = Foo(...)
// any = Any()
// any.Pack(foo)
// ...
// if any.Is(Foo.DESCRIPTOR):
// any.Unpack(foo)
// ...
//
// Example 4: Pack and unpack a message in Go
//
// foo := &pb.Foo{...}
// any, err := ptypes.MarshalAny(foo)
// ...
// foo := &pb.Foo{}
// if err := ptypes.UnmarshalAny(any, foo); err != nil {
// ...
// }
//
// The pack methods provided by protobuf library will by default use
// 'type.googleapis.com/full.type.name' as the type URL and the unpack
// methods only use the fully qualified type name after the last '/'
// in the type URL, for example "foo.bar.com/x/y.z" will yield type
// name "y.z".
//
//
// JSON
// ====
// The JSON representation of an `Any` value uses the regular
// representation of the deserialized, embedded message, with an
// additional field `@type` which contains the type URL. Example:
//
// package google.profile;
// message Person {
// string first_name = 1;
// string last_name = 2;
// }
//
// {
// "@type": "type.googleapis.com/google.profile.Person",
// "firstName": <string>,
// "lastName": <string>
// }
//
// If the embedded message type is well-known and has a custom JSON
// representation, that representation will be embedded adding a field
// `value` which holds the custom JSON in addition to the `@type`
// field. Example (for message [google.protobuf.Duration][]):
//
// {
// "@type": "type.googleapis.com/google.protobuf.Duration",
// "value": "1.212s"
// }
//
type Any struct {
// A URL/resource name that uniquely identifies the type of the serialized
// protocol buffer message. This string must contain at least
// one "/" character. The last segment of the URL's path must represent
// the fully qualified name of the type (as in
// `path/google.protobuf.Duration`). The name should be in a canonical form
// (e.g., leading "." is not accepted).
//
// In practice, teams usually precompile into the binary all types that they
// expect it to use in the context of Any. However, for URLs which use the
// scheme `http`, `https`, or no scheme, one can optionally set up a type
// server that maps type URLs to message definitions as follows:
//
// * If no scheme is provided, `https` is assumed.
// * An HTTP GET on the URL must yield a [google.protobuf.Type][]
// value in binary format, or produce an error.
// * Applications are allowed to cache lookup results based on the
// URL, or have them precompiled into a binary to avoid any
// lookup. Therefore, binary compatibility needs to be preserved
// on changes to types. (Use versioned type names to manage
// breaking changes.)
//
// Note: this functionality is not currently available in the official
// protobuf release, and it is not used for type URLs beginning with
// type.googleapis.com.
//
// Schemes other than `http`, `https` (or the empty scheme) might be
// used with implementation specific semantics.
//
TypeUrl string `protobuf:"bytes,1,opt,name=type_url,json=typeUrl,proto3" json:"type_url,omitempty"`
// Must be a valid serialized protocol buffer of the above specified type.
Value []byte `protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
var File_github_com_golang_protobuf_ptypes_any_any_proto protoreflect.FileDescriptor
var file_github_com_golang_protobuf_ptypes_any_any_proto_rawDesc = []byte{
0x0a, 0x2f, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x6f, 0x6c,
0x61, 0x6e, 0x67, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x70, 0x74, 0x79,
0x70, 0x65, 0x73, 0x2f, 0x61, 0x6e, 0x79, 0x2f, 0x61, 0x6e, 0x79, 0x2e, 0x70, 0x72, 0x6f, 0x74,
0x6f, 0x1a, 0x19, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62,
0x75, 0x66, 0x2f, 0x61, 0x6e, 0x79, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x42, 0x2b, 0x5a, 0x29,
0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x6f, 0x6c, 0x61, 0x6e,
0x67, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x70, 0x74, 0x79, 0x70, 0x65,
0x73, 0x2f, 0x61, 0x6e, 0x79, 0x3b, 0x61, 0x6e, 0x79, 0x50, 0x00, 0x62, 0x06, 0x70, 0x72, 0x6f,
0x74, 0x6f, 0x33,
}
func (m *Any) Reset() { *m = Any{} }
func (m *Any) String() string { return proto.CompactTextString(m) }
func (*Any) ProtoMessage() {}
func (*Any) Descriptor() ([]byte, []int) {
return fileDescriptor_b53526c13ae22eb4, []int{0}
var file_github_com_golang_protobuf_ptypes_any_any_proto_goTypes = []interface{}{}
var file_github_com_golang_protobuf_ptypes_any_any_proto_depIdxs = []int32{
0, // [0:0] is the sub-list for method output_type
0, // [0:0] is the sub-list for method input_type
0, // [0:0] is the sub-list for extension type_name
0, // [0:0] is the sub-list for extension extendee
0, // [0:0] is the sub-list for field type_name
}
func (*Any) XXX_WellKnownType() string { return "Any" }
func (m *Any) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_Any.Unmarshal(m, b)
}
func (m *Any) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_Any.Marshal(b, m, deterministic)
}
func (m *Any) XXX_Merge(src proto.Message) {
xxx_messageInfo_Any.Merge(m, src)
}
func (m *Any) XXX_Size() int {
return xxx_messageInfo_Any.Size(m)
}
func (m *Any) XXX_DiscardUnknown() {
xxx_messageInfo_Any.DiscardUnknown(m)
}
var xxx_messageInfo_Any proto.InternalMessageInfo
func (m *Any) GetTypeUrl() string {
if m != nil {
return m.TypeUrl
func init() { file_github_com_golang_protobuf_ptypes_any_any_proto_init() }
func file_github_com_golang_protobuf_ptypes_any_any_proto_init() {
if File_github_com_golang_protobuf_ptypes_any_any_proto != nil {
return
}
return ""
}
func (m *Any) GetValue() []byte {
if m != nil {
return m.Value
}
return nil
}
func init() {
proto.RegisterType((*Any)(nil), "google.protobuf.Any")
}
func init() {
proto.RegisterFile("google/protobuf/any.proto", fileDescriptor_b53526c13ae22eb4)
}
var fileDescriptor_b53526c13ae22eb4 = []byte{
// 185 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x92, 0x4c, 0xcf, 0xcf, 0x4f,
0xcf, 0x49, 0xd5, 0x2f, 0x28, 0xca, 0x2f, 0xc9, 0x4f, 0x2a, 0x4d, 0xd3, 0x4f, 0xcc, 0xab, 0xd4,
0x03, 0x73, 0x84, 0xf8, 0x21, 0x52, 0x7a, 0x30, 0x29, 0x25, 0x33, 0x2e, 0x66, 0xc7, 0xbc, 0x4a,
0x21, 0x49, 0x2e, 0x8e, 0x92, 0xca, 0x82, 0xd4, 0xf8, 0xd2, 0xa2, 0x1c, 0x09, 0x46, 0x05, 0x46,
0x0d, 0xce, 0x20, 0x76, 0x10, 0x3f, 0xb4, 0x28, 0x47, 0x48, 0x84, 0x8b, 0xb5, 0x2c, 0x31, 0xa7,
0x34, 0x55, 0x82, 0x49, 0x81, 0x51, 0x83, 0x27, 0x08, 0xc2, 0x71, 0xca, 0xe7, 0x12, 0x4e, 0xce,
0xcf, 0xd5, 0x43, 0x33, 0xce, 0x89, 0xc3, 0x31, 0xaf, 0x32, 0x00, 0xc4, 0x09, 0x60, 0x8c, 0x52,
0x4d, 0xcf, 0x2c, 0xc9, 0x28, 0x4d, 0xd2, 0x4b, 0xce, 0xcf, 0xd5, 0x4f, 0xcf, 0xcf, 0x49, 0xcc,
0x4b, 0x47, 0xb8, 0xa8, 0x00, 0x64, 0x7a, 0x31, 0xc8, 0x61, 0x8b, 0x98, 0x98, 0xdd, 0x03, 0x9c,
0x56, 0x31, 0xc9, 0xb9, 0x43, 0x8c, 0x0a, 0x80, 0x2a, 0xd1, 0x0b, 0x4f, 0xcd, 0xc9, 0xf1, 0xce,
0xcb, 0x2f, 0xcf, 0x0b, 0x01, 0x29, 0x4d, 0x62, 0x03, 0xeb, 0x35, 0x06, 0x04, 0x00, 0x00, 0xff,
0xff, 0x13, 0xf8, 0xe8, 0x42, 0xdd, 0x00, 0x00, 0x00,
type x struct{}
out := protoimpl.TypeBuilder{
File: protoimpl.DescBuilder{
GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
RawDescriptor: file_github_com_golang_protobuf_ptypes_any_any_proto_rawDesc,
NumEnums: 0,
NumMessages: 0,
NumExtensions: 0,
NumServices: 0,
},
GoTypes: file_github_com_golang_protobuf_ptypes_any_any_proto_goTypes,
DependencyIndexes: file_github_com_golang_protobuf_ptypes_any_any_proto_depIdxs,
}.Build()
File_github_com_golang_protobuf_ptypes_any_any_proto = out.File
file_github_com_golang_protobuf_ptypes_any_any_proto_rawDesc = nil
file_github_com_golang_protobuf_ptypes_any_any_proto_goTypes = nil
file_github_com_golang_protobuf_ptypes_any_any_proto_depIdxs = nil
}

155
vendor/github.com/golang/protobuf/ptypes/any/any.proto generated vendored
View file

@ -1,155 +0,0 @@
// Protocol Buffers - Google's data interchange format
// Copyright 2008 Google Inc. All rights reserved.
// https://developers.google.com/protocol-buffers/
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
// * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
// * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following disclaimer
// in the documentation and/or other materials provided with the
// distribution.
// * Neither the name of Google Inc. nor the names of its
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
syntax = "proto3";
package google.protobuf;
option csharp_namespace = "Google.Protobuf.WellKnownTypes";
option go_package = "github.com/golang/protobuf/ptypes/any";
option java_package = "com.google.protobuf";
option java_outer_classname = "AnyProto";
option java_multiple_files = true;
option objc_class_prefix = "GPB";
// `Any` contains an arbitrary serialized protocol buffer message along with a
// URL that describes the type of the serialized message.
//
// Protobuf library provides support to pack/unpack Any values in the form
// of utility functions or additional generated methods of the Any type.
//
// Example 1: Pack and unpack a message in C++.
//
// Foo foo = ...;
// Any any;
// any.PackFrom(foo);
// ...
// if (any.UnpackTo(&foo)) {
// ...
// }
//
// Example 2: Pack and unpack a message in Java.
//
// Foo foo = ...;
// Any any = Any.pack(foo);
// ...
// if (any.is(Foo.class)) {
// foo = any.unpack(Foo.class);
// }
//
// Example 3: Pack and unpack a message in Python.
//
// foo = Foo(...)
// any = Any()
// any.Pack(foo)
// ...
// if any.Is(Foo.DESCRIPTOR):
// any.Unpack(foo)
// ...
//
// Example 4: Pack and unpack a message in Go
//
// foo := &pb.Foo{...}
// any, err := ptypes.MarshalAny(foo)
// ...
// foo := &pb.Foo{}
// if err := ptypes.UnmarshalAny(any, foo); err != nil {
// ...
// }
//
// The pack methods provided by protobuf library will by default use
// 'type.googleapis.com/full.type.name' as the type URL and the unpack
// methods only use the fully qualified type name after the last '/'
// in the type URL, for example "foo.bar.com/x/y.z" will yield type
// name "y.z".
//
//
// JSON
// ====
// The JSON representation of an `Any` value uses the regular
// representation of the deserialized, embedded message, with an
// additional field `@type` which contains the type URL. Example:
//
// package google.profile;
// message Person {
// string first_name = 1;
// string last_name = 2;
// }
//
// {
// "@type": "type.googleapis.com/google.profile.Person",
// "firstName": <string>,
// "lastName": <string>
// }
//
// If the embedded message type is well-known and has a custom JSON
// representation, that representation will be embedded adding a field
// `value` which holds the custom JSON in addition to the `@type`
// field. Example (for message [google.protobuf.Duration][]):
//
// {
// "@type": "type.googleapis.com/google.protobuf.Duration",
// "value": "1.212s"
// }
//
message Any {
// A URL/resource name that uniquely identifies the type of the serialized
// protocol buffer message. This string must contain at least
// one "/" character. The last segment of the URL's path must represent
// the fully qualified name of the type (as in
// `path/google.protobuf.Duration`). The name should be in a canonical form
// (e.g., leading "." is not accepted).
//
// In practice, teams usually precompile into the binary all types that they
// expect it to use in the context of Any. However, for URLs which use the
// scheme `http`, `https`, or no scheme, one can optionally set up a type
// server that maps type URLs to message definitions as follows:
//
// * If no scheme is provided, `https` is assumed.
// * An HTTP GET on the URL must yield a [google.protobuf.Type][]
// value in binary format, or produce an error.
// * Applications are allowed to cache lookup results based on the
// URL, or have them precompiled into a binary to avoid any
// lookup. Therefore, binary compatibility needs to be preserved
// on changes to types. (Use versioned type names to manage
// breaking changes.)
//
// Note: this functionality is not currently available in the official
// protobuf release, and it is not used for type URLs beginning with
// type.googleapis.com.
//
// Schemes other than `http`, `https` (or the empty scheme) might be
// used with implementation specific semantics.
//
string type_url = 1;
// Must be a valid serialized protocol buffer of the above specified type.
bytes value = 2;
}

37
vendor/github.com/golang/protobuf/ptypes/doc.go generated vendored
View file

@ -1,35 +1,6 @@
// Go support for Protocol Buffers - Google's data interchange format
//
// Copyright 2016 The Go Authors. All rights reserved.
// https://github.com/golang/protobuf
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
// * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
// * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following disclaimer
// in the documentation and/or other materials provided with the
// distribution.
// * Neither the name of Google Inc. nor the names of its
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
// Copyright 2016 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
/*
Package ptypes contains code for interacting with well-known types.
*/
// Package ptypes provides functionality for interacting with well-known types.
package ptypes

116
vendor/github.com/golang/protobuf/ptypes/duration.go generated vendored
View file

@ -1,102 +1,72 @@
// Go support for Protocol Buffers - Google's data interchange format
//
// Copyright 2016 The Go Authors. All rights reserved.
// https://github.com/golang/protobuf
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
// * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
// * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following disclaimer
// in the documentation and/or other materials provided with the
// distribution.
// * Neither the name of Google Inc. nor the names of its
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
// Copyright 2016 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
package ptypes
// This file implements conversions between google.protobuf.Duration
// and time.Duration.
import (
"errors"
"fmt"
"time"
durpb "github.com/golang/protobuf/ptypes/duration"
durationpb "github.com/golang/protobuf/ptypes/duration"
)
// Range of google.protobuf.Duration as specified in duration.proto.
// This is about 10,000 years in seconds.
const (
// Range of a durpb.Duration in seconds, as specified in
// google/protobuf/duration.proto. This is about 10,000 years in seconds.
maxSeconds = int64(10000 * 365.25 * 24 * 60 * 60)
minSeconds = -maxSeconds
)
// validateDuration determines whether the durpb.Duration is valid according to the
// definition in google/protobuf/duration.proto. A valid durpb.Duration
// may still be too large to fit into a time.Duration (the range of durpb.Duration
// is about 10,000 years, and the range of time.Duration is about 290).
func validateDuration(d *durpb.Duration) error {
if d == nil {
return errors.New("duration: nil Duration")
}
if d.Seconds < minSeconds || d.Seconds > maxSeconds {
return fmt.Errorf("duration: %v: seconds out of range", d)
}
if d.Nanos <= -1e9 || d.Nanos >= 1e9 {
return fmt.Errorf("duration: %v: nanos out of range", d)
}
// Seconds and Nanos must have the same sign, unless d.Nanos is zero.
if (d.Seconds < 0 && d.Nanos > 0) || (d.Seconds > 0 && d.Nanos < 0) {
return fmt.Errorf("duration: %v: seconds and nanos have different signs", d)
}
return nil
}
// Duration converts a durpb.Duration to a time.Duration. Duration
// returns an error if the durpb.Duration is invalid or is too large to be
// represented in a time.Duration.
func Duration(p *durpb.Duration) (time.Duration, error) {
if err := validateDuration(p); err != nil {
// Duration converts a durationpb.Duration to a time.Duration.
// Duration returns an error if dur is invalid or overflows a time.Duration.
func Duration(dur *durationpb.Duration) (time.Duration, error) {
if err := validateDuration(dur); err != nil {
return 0, err
}
d := time.Duration(p.Seconds) * time.Second
if int64(d/time.Second) != p.Seconds {
return 0, fmt.Errorf("duration: %v is out of range for time.Duration", p)
d := time.Duration(dur.Seconds) * time.Second
if int64(d/time.Second) != dur.Seconds {
return 0, fmt.Errorf("duration: %v is out of range for time.Duration", dur)
}
if p.Nanos != 0 {
d += time.Duration(p.Nanos) * time.Nanosecond
if (d < 0) != (p.Nanos < 0) {
return 0, fmt.Errorf("duration: %v is out of range for time.Duration", p)
if dur.Nanos != 0 {
d += time.Duration(dur.Nanos) * time.Nanosecond
if (d < 0) != (dur.Nanos < 0) {
return 0, fmt.Errorf("duration: %v is out of range for time.Duration", dur)
}
}
return d, nil
}
// DurationProto converts a time.Duration to a durpb.Duration.
func DurationProto(d time.Duration) *durpb.Duration {
// DurationProto converts a time.Duration to a durationpb.Duration.
func DurationProto(d time.Duration) *durationpb.Duration {
nanos := d.Nanoseconds()
secs := nanos / 1e9
nanos -= secs * 1e9
return &durpb.Duration{
Seconds: secs,
return &durationpb.Duration{
Seconds: int64(secs),
Nanos: int32(nanos),
}
}
// validateDuration determines whether the durationpb.Duration is valid
// according to the definition in google/protobuf/duration.proto.
// A valid durpb.Duration may still be too large to fit into a time.Duration
// Note that the range of durationpb.Duration is about 10,000 years,
// while the range of time.Duration is about 290 years.
func validateDuration(dur *durationpb.Duration) error {
if dur == nil {
return errors.New("duration: nil Duration")
}
if dur.Seconds < minSeconds || dur.Seconds > maxSeconds {
return fmt.Errorf("duration: %v: seconds out of range", dur)
}
if dur.Nanos <= -1e9 || dur.Nanos >= 1e9 {
return fmt.Errorf("duration: %v: nanos out of range", dur)
}
// Seconds and Nanos must have the same sign, unless d.Nanos is zero.
if (dur.Seconds < 0 && dur.Nanos > 0) || (dur.Seconds > 0 && dur.Nanos < 0) {
return fmt.Errorf("duration: %v: seconds and nanos have different signs", dur)
}
return nil
}

196
vendor/github.com/golang/protobuf/ptypes/duration/duration.pb.go generated vendored
View file

@ -1,163 +1,63 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
// source: google/protobuf/duration.proto
// source: github.com/golang/protobuf/ptypes/duration/duration.proto
package duration
import (
fmt "fmt"
proto "github.com/golang/protobuf/proto"
math "math"
protoreflect "google.golang.org/protobuf/reflect/protoreflect"
protoimpl "google.golang.org/protobuf/runtime/protoimpl"
durationpb "google.golang.org/protobuf/types/known/durationpb"
reflect "reflect"
)
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf
// Symbols defined in public import of google/protobuf/duration.proto.
// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.ProtoPackageIsVersion3 // please upgrade the proto package
type Duration = durationpb.Duration
// A Duration represents a signed, fixed-length span of time represented
// as a count of seconds and fractions of seconds at nanosecond
// resolution. It is independent of any calendar and concepts like "day"
// or "month". It is related to Timestamp in that the difference between
// two Timestamp values is a Duration and it can be added or subtracted
// from a Timestamp. Range is approximately +-10,000 years.
//
// # Examples
//
// Example 1: Compute Duration from two Timestamps in pseudo code.
//
// Timestamp start = ...;
// Timestamp end = ...;
// Duration duration = ...;
//
// duration.seconds = end.seconds - start.seconds;
// duration.nanos = end.nanos - start.nanos;
//
// if (duration.seconds < 0 && duration.nanos > 0) {
// duration.seconds += 1;
// duration.nanos -= 1000000000;
// } else if (duration.seconds > 0 && duration.nanos < 0) {
// duration.seconds -= 1;
// duration.nanos += 1000000000;
// }
//
// Example 2: Compute Timestamp from Timestamp + Duration in pseudo code.
//
// Timestamp start = ...;
// Duration duration = ...;
// Timestamp end = ...;
//
// end.seconds = start.seconds + duration.seconds;
// end.nanos = start.nanos + duration.nanos;
//
// if (end.nanos < 0) {
// end.seconds -= 1;
// end.nanos += 1000000000;
// } else if (end.nanos >= 1000000000) {
// end.seconds += 1;
// end.nanos -= 1000000000;
// }
//
// Example 3: Compute Duration from datetime.timedelta in Python.
//
// td = datetime.timedelta(days=3, minutes=10)
// duration = Duration()
// duration.FromTimedelta(td)
//
// # JSON Mapping
//
// In JSON format, the Duration type is encoded as a string rather than an
// object, where the string ends in the suffix "s" (indicating seconds) and
// is preceded by the number of seconds, with nanoseconds expressed as
// fractional seconds. For example, 3 seconds with 0 nanoseconds should be
// encoded in JSON format as "3s", while 3 seconds and 1 nanosecond should
// be expressed in JSON format as "3.000000001s", and 3 seconds and 1
// microsecond should be expressed in JSON format as "3.000001s".
//
//
type Duration struct {
// Signed seconds of the span of time. Must be from -315,576,000,000
// to +315,576,000,000 inclusive. Note: these bounds are computed from:
// 60 sec/min * 60 min/hr * 24 hr/day * 365.25 days/year * 10000 years
Seconds int64 `protobuf:"varint,1,opt,name=seconds,proto3" json:"seconds,omitempty"`
// Signed fractions of a second at nanosecond resolution of the span
// of time. Durations less than one second are represented with a 0
// `seconds` field and a positive or negative `nanos` field. For durations
// of one second or more, a non-zero value for the `nanos` field must be
// of the same sign as the `seconds` field. Must be from -999,999,999
// to +999,999,999 inclusive.
Nanos int32 `protobuf:"varint,2,opt,name=nanos,proto3" json:"nanos,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
var File_github_com_golang_protobuf_ptypes_duration_duration_proto protoreflect.FileDescriptor
var file_github_com_golang_protobuf_ptypes_duration_duration_proto_rawDesc = []byte{
0x0a, 0x39, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x6f, 0x6c,
0x61, 0x6e, 0x67, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x70, 0x74, 0x79,
0x70, 0x65, 0x73, 0x2f, 0x64, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x2f, 0x64, 0x75, 0x72,
0x61, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x1e, 0x67, 0x6f, 0x6f,
0x67, 0x6c, 0x65, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x64, 0x75, 0x72,
0x61, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x42, 0x35, 0x5a, 0x33, 0x67,
0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x6f, 0x6c, 0x61, 0x6e, 0x67,
0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x70, 0x74, 0x79, 0x70, 0x65, 0x73,
0x2f, 0x64, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x3b, 0x64, 0x75, 0x72, 0x61, 0x74, 0x69,
0x6f, 0x6e, 0x50, 0x00, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
}
func (m *Duration) Reset() { *m = Duration{} }
func (m *Duration) String() string { return proto.CompactTextString(m) }
func (*Duration) ProtoMessage() {}
func (*Duration) Descriptor() ([]byte, []int) {
return fileDescriptor_23597b2ebd7ac6c5, []int{0}
var file_github_com_golang_protobuf_ptypes_duration_duration_proto_goTypes = []interface{}{}
var file_github_com_golang_protobuf_ptypes_duration_duration_proto_depIdxs = []int32{
0, // [0:0] is the sub-list for method output_type
0, // [0:0] is the sub-list for method input_type
0, // [0:0] is the sub-list for extension type_name
0, // [0:0] is the sub-list for extension extendee
0, // [0:0] is the sub-list for field type_name
}
func (*Duration) XXX_WellKnownType() string { return "Duration" }
func (m *Duration) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_Duration.Unmarshal(m, b)
}
func (m *Duration) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_Duration.Marshal(b, m, deterministic)
}
func (m *Duration) XXX_Merge(src proto.Message) {
xxx_messageInfo_Duration.Merge(m, src)
}
func (m *Duration) XXX_Size() int {
return xxx_messageInfo_Duration.Size(m)
}
func (m *Duration) XXX_DiscardUnknown() {
xxx_messageInfo_Duration.DiscardUnknown(m)
}
var xxx_messageInfo_Duration proto.InternalMessageInfo
func (m *Duration) GetSeconds() int64 {
if m != nil {
return m.Seconds
func init() { file_github_com_golang_protobuf_ptypes_duration_duration_proto_init() }
func file_github_com_golang_protobuf_ptypes_duration_duration_proto_init() {
if File_github_com_golang_protobuf_ptypes_duration_duration_proto != nil {
return
}
return 0
}
func (m *Duration) GetNanos() int32 {
if m != nil {
return m.Nanos
}
return 0
}
func init() {
proto.RegisterType((*Duration)(nil), "google.protobuf.Duration")
}
func init() {
proto.RegisterFile("google/protobuf/duration.proto", fileDescriptor_23597b2ebd7ac6c5)
}
var fileDescriptor_23597b2ebd7ac6c5 = []byte{
// 190 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x92, 0x4b, 0xcf, 0xcf, 0x4f,
0xcf, 0x49, 0xd5, 0x2f, 0x28, 0xca, 0x2f, 0xc9, 0x4f, 0x2a, 0x4d, 0xd3, 0x4f, 0x29, 0x2d, 0x4a,
0x2c, 0xc9, 0xcc, 0xcf, 0xd3, 0x03, 0x8b, 0x08, 0xf1, 0x43, 0xe4, 0xf5, 0x60, 0xf2, 0x4a, 0x56,
0x5c, 0x1c, 0x2e, 0x50, 0x25, 0x42, 0x12, 0x5c, 0xec, 0xc5, 0xa9, 0xc9, 0xf9, 0x79, 0x29, 0xc5,
0x12, 0x8c, 0x0a, 0x8c, 0x1a, 0xcc, 0x41, 0x30, 0xae, 0x90, 0x08, 0x17, 0x6b, 0x5e, 0x62, 0x5e,
0x7e, 0xb1, 0x04, 0x93, 0x02, 0xa3, 0x06, 0x6b, 0x10, 0x84, 0xe3, 0x54, 0xc3, 0x25, 0x9c, 0x9c,
0x9f, 0xab, 0x87, 0x66, 0xa4, 0x13, 0x2f, 0xcc, 0xc0, 0x00, 0x90, 0x48, 0x00, 0x63, 0x94, 0x56,
0x7a, 0x66, 0x49, 0x46, 0x69, 0x92, 0x5e, 0x72, 0x7e, 0xae, 0x7e, 0x7a, 0x7e, 0x4e, 0x62, 0x5e,
0x3a, 0xc2, 0x7d, 0x05, 0x25, 0x95, 0x05, 0xa9, 0xc5, 0x70, 0x67, 0xfe, 0x60, 0x64, 0x5c, 0xc4,
0xc4, 0xec, 0x1e, 0xe0, 0xb4, 0x8a, 0x49, 0xce, 0x1d, 0x62, 0x6e, 0x00, 0x54, 0xa9, 0x5e, 0x78,
0x6a, 0x4e, 0x8e, 0x77, 0x5e, 0x7e, 0x79, 0x5e, 0x08, 0x48, 0x4b, 0x12, 0x1b, 0xd8, 0x0c, 0x63,
0x40, 0x00, 0x00, 0x00, 0xff, 0xff, 0xdc, 0x84, 0x30, 0xff, 0xf3, 0x00, 0x00, 0x00,
type x struct{}
out := protoimpl.TypeBuilder{
File: protoimpl.DescBuilder{
GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
RawDescriptor: file_github_com_golang_protobuf_ptypes_duration_duration_proto_rawDesc,
NumEnums: 0,
NumMessages: 0,
NumExtensions: 0,
NumServices: 0,
},
GoTypes: file_github_com_golang_protobuf_ptypes_duration_duration_proto_goTypes,
DependencyIndexes: file_github_com_golang_protobuf_ptypes_duration_duration_proto_depIdxs,
}.Build()
File_github_com_golang_protobuf_ptypes_duration_duration_proto = out.File
file_github_com_golang_protobuf_ptypes_duration_duration_proto_rawDesc = nil
file_github_com_golang_protobuf_ptypes_duration_duration_proto_goTypes = nil
file_github_com_golang_protobuf_ptypes_duration_duration_proto_depIdxs = nil
}

116
vendor/github.com/golang/protobuf/ptypes/duration/duration.proto generated vendored
View file

@ -1,116 +0,0 @@
// Protocol Buffers - Google's data interchange format
// Copyright 2008 Google Inc. All rights reserved.
// https://developers.google.com/protocol-buffers/
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
// * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
// * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following disclaimer
// in the documentation and/or other materials provided with the
// distribution.
// * Neither the name of Google Inc. nor the names of its
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
syntax = "proto3";
package google.protobuf;
option csharp_namespace = "Google.Protobuf.WellKnownTypes";
option cc_enable_arenas = true;
option go_package = "github.com/golang/protobuf/ptypes/duration";
option java_package = "com.google.protobuf";
option java_outer_classname = "DurationProto";
option java_multiple_files = true;
option objc_class_prefix = "GPB";
// A Duration represents a signed, fixed-length span of time represented
// as a count of seconds and fractions of seconds at nanosecond
// resolution. It is independent of any calendar and concepts like "day"
// or "month". It is related to Timestamp in that the difference between
// two Timestamp values is a Duration and it can be added or subtracted
// from a Timestamp. Range is approximately +-10,000 years.
//
// # Examples
//
// Example 1: Compute Duration from two Timestamps in pseudo code.
//
// Timestamp start = ...;
// Timestamp end = ...;
// Duration duration = ...;
//
// duration.seconds = end.seconds - start.seconds;
// duration.nanos = end.nanos - start.nanos;
//
// if (duration.seconds < 0 && duration.nanos > 0) {
// duration.seconds += 1;
// duration.nanos -= 1000000000;
// } else if (duration.seconds > 0 && duration.nanos < 0) {
// duration.seconds -= 1;
// duration.nanos += 1000000000;
// }
//
// Example 2: Compute Timestamp from Timestamp + Duration in pseudo code.
//
// Timestamp start = ...;
// Duration duration = ...;
// Timestamp end = ...;
//
// end.seconds = start.seconds + duration.seconds;
// end.nanos = start.nanos + duration.nanos;
//
// if (end.nanos < 0) {
// end.seconds -= 1;
// end.nanos += 1000000000;
// } else if (end.nanos >= 1000000000) {
// end.seconds += 1;
// end.nanos -= 1000000000;
// }
//
// Example 3: Compute Duration from datetime.timedelta in Python.
//
// td = datetime.timedelta(days=3, minutes=10)
// duration = Duration()
// duration.FromTimedelta(td)
//
// # JSON Mapping
//
// In JSON format, the Duration type is encoded as a string rather than an
// object, where the string ends in the suffix "s" (indicating seconds) and
// is preceded by the number of seconds, with nanoseconds expressed as
// fractional seconds. For example, 3 seconds with 0 nanoseconds should be
// encoded in JSON format as "3s", while 3 seconds and 1 nanosecond should
// be expressed in JSON format as "3.000000001s", and 3 seconds and 1
// microsecond should be expressed in JSON format as "3.000001s".
//
//
message Duration {
// Signed seconds of the span of time. Must be from -315,576,000,000
// to +315,576,000,000 inclusive. Note: these bounds are computed from:
// 60 sec/min * 60 min/hr * 24 hr/day * 365.25 days/year * 10000 years
int64 seconds = 1;
// Signed fractions of a second at nanosecond resolution of the span
// of time. Durations less than one second are represented with a 0
// `seconds` field and a positive or negative `nanos` field. For durations
// of one second or more, a non-zero value for the `nanos` field must be
// of the same sign as the `seconds` field. Must be from -999,999,999
// to +999,999,999 inclusive.
int32 nanos = 2;
}

119
vendor/github.com/golang/protobuf/ptypes/empty/empty.pb.go generated vendored
View file

@ -1,85 +1,62 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
// source: google/protobuf/empty.proto
// source: github.com/golang/protobuf/ptypes/empty/empty.proto
package empty
import (
fmt "fmt"
proto "github.com/golang/protobuf/proto"
math "math"
protoreflect "google.golang.org/protobuf/reflect/protoreflect"
protoimpl "google.golang.org/protobuf/runtime/protoimpl"
emptypb "google.golang.org/protobuf/types/known/emptypb"
reflect "reflect"
)
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf
// Symbols defined in public import of google/protobuf/empty.proto.
// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.ProtoPackageIsVersion3 // please upgrade the proto package
type Empty = emptypb.Empty
// A generic empty message that you can re-use to avoid defining duplicated
// empty messages in your APIs. A typical example is to use it as the request
// or the response type of an API method. For instance:
//
// service Foo {
// rpc Bar(google.protobuf.Empty) returns (google.protobuf.Empty);
// }
//
// The JSON representation for `Empty` is empty JSON object `{}`.
type Empty struct {
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
var File_github_com_golang_protobuf_ptypes_empty_empty_proto protoreflect.FileDescriptor
var file_github_com_golang_protobuf_ptypes_empty_empty_proto_rawDesc = []byte{
0x0a, 0x33, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x6f, 0x6c,
0x61, 0x6e, 0x67, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x70, 0x74, 0x79,
0x70, 0x65, 0x73, 0x2f, 0x65, 0x6d, 0x70, 0x74, 0x79, 0x2f, 0x65, 0x6d, 0x70, 0x74, 0x79, 0x2e,
0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x1b, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2f, 0x70, 0x72,
0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x65, 0x6d, 0x70, 0x74, 0x79, 0x2e, 0x70, 0x72, 0x6f,
0x74, 0x6f, 0x42, 0x2f, 0x5a, 0x2d, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d,
0x2f, 0x67, 0x6f, 0x6c, 0x61, 0x6e, 0x67, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66,
0x2f, 0x70, 0x74, 0x79, 0x70, 0x65, 0x73, 0x2f, 0x65, 0x6d, 0x70, 0x74, 0x79, 0x3b, 0x65, 0x6d,
0x70, 0x74, 0x79, 0x50, 0x00, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
}
func (m *Empty) Reset() { *m = Empty{} }
func (m *Empty) String() string { return proto.CompactTextString(m) }
func (*Empty) ProtoMessage() {}
func (*Empty) Descriptor() ([]byte, []int) {
return fileDescriptor_900544acb223d5b8, []int{0}
var file_github_com_golang_protobuf_ptypes_empty_empty_proto_goTypes = []interface{}{}
var file_github_com_golang_protobuf_ptypes_empty_empty_proto_depIdxs = []int32{
0, // [0:0] is the sub-list for method output_type
0, // [0:0] is the sub-list for method input_type
0, // [0:0] is the sub-list for extension type_name
0, // [0:0] is the sub-list for extension extendee
0, // [0:0] is the sub-list for field type_name
}
func (*Empty) XXX_WellKnownType() string { return "Empty" }
func (m *Empty) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_Empty.Unmarshal(m, b)
}
func (m *Empty) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_Empty.Marshal(b, m, deterministic)
}
func (m *Empty) XXX_Merge(src proto.Message) {
xxx_messageInfo_Empty.Merge(m, src)
}
func (m *Empty) XXX_Size() int {
return xxx_messageInfo_Empty.Size(m)
}
func (m *Empty) XXX_DiscardUnknown() {
xxx_messageInfo_Empty.DiscardUnknown(m)
}
var xxx_messageInfo_Empty proto.InternalMessageInfo
func init() {
proto.RegisterType((*Empty)(nil), "google.protobuf.Empty")
}
func init() {
proto.RegisterFile("google/protobuf/empty.proto", fileDescriptor_900544acb223d5b8)
}
var fileDescriptor_900544acb223d5b8 = []byte{
// 148 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x92, 0x4e, 0xcf, 0xcf, 0x4f,
0xcf, 0x49, 0xd5, 0x2f, 0x28, 0xca, 0x2f, 0xc9, 0x4f, 0x2a, 0x4d, 0xd3, 0x4f, 0xcd, 0x2d, 0x28,
0xa9, 0xd4, 0x03, 0x73, 0x85, 0xf8, 0x21, 0x92, 0x7a, 0x30, 0x49, 0x25, 0x76, 0x2e, 0x56, 0x57,
0x90, 0xbc, 0x53, 0x19, 0x97, 0x70, 0x72, 0x7e, 0xae, 0x1e, 0x9a, 0xbc, 0x13, 0x17, 0x58, 0x36,
0x00, 0xc4, 0x0d, 0x60, 0x8c, 0x52, 0x4f, 0xcf, 0x2c, 0xc9, 0x28, 0x4d, 0xd2, 0x4b, 0xce, 0xcf,
0xd5, 0x4f, 0xcf, 0xcf, 0x49, 0xcc, 0x4b, 0x47, 0x58, 0x53, 0x50, 0x52, 0x59, 0x90, 0x5a, 0x0c,
0xb1, 0xed, 0x07, 0x23, 0xe3, 0x22, 0x26, 0x66, 0xf7, 0x00, 0xa7, 0x55, 0x4c, 0x72, 0xee, 0x10,
0x13, 0x03, 0xa0, 0xea, 0xf4, 0xc2, 0x53, 0x73, 0x72, 0xbc, 0xf3, 0xf2, 0xcb, 0xf3, 0x42, 0x40,
0xea, 0x93, 0xd8, 0xc0, 0x06, 0x18, 0x03, 0x02, 0x00, 0x00, 0xff, 0xff, 0x64, 0xd4, 0xb3, 0xa6,
0xb7, 0x00, 0x00, 0x00,
func init() { file_github_com_golang_protobuf_ptypes_empty_empty_proto_init() }
func file_github_com_golang_protobuf_ptypes_empty_empty_proto_init() {
if File_github_com_golang_protobuf_ptypes_empty_empty_proto != nil {
return
}
type x struct{}
out := protoimpl.TypeBuilder{
File: protoimpl.DescBuilder{
GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
RawDescriptor: file_github_com_golang_protobuf_ptypes_empty_empty_proto_rawDesc,
NumEnums: 0,
NumMessages: 0,
NumExtensions: 0,
NumServices: 0,
},
GoTypes: file_github_com_golang_protobuf_ptypes_empty_empty_proto_goTypes,
DependencyIndexes: file_github_com_golang_protobuf_ptypes_empty_empty_proto_depIdxs,
}.Build()
File_github_com_golang_protobuf_ptypes_empty_empty_proto = out.File
file_github_com_golang_protobuf_ptypes_empty_empty_proto_rawDesc = nil
file_github_com_golang_protobuf_ptypes_empty_empty_proto_goTypes = nil
file_github_com_golang_protobuf_ptypes_empty_empty_proto_depIdxs = nil
}

52
vendor/github.com/golang/protobuf/ptypes/empty/empty.proto generated vendored
View file

@ -1,52 +0,0 @@
// Protocol Buffers - Google's data interchange format
// Copyright 2008 Google Inc. All rights reserved.
// https://developers.google.com/protocol-buffers/
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
// * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
// * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following disclaimer
// in the documentation and/or other materials provided with the
// distribution.
// * Neither the name of Google Inc. nor the names of its
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
syntax = "proto3";
package google.protobuf;
option csharp_namespace = "Google.Protobuf.WellKnownTypes";
option go_package = "github.com/golang/protobuf/ptypes/empty";
option java_package = "com.google.protobuf";
option java_outer_classname = "EmptyProto";
option java_multiple_files = true;
option objc_class_prefix = "GPB";
option cc_enable_arenas = true;
// A generic empty message that you can re-use to avoid defining duplicated
// empty messages in your APIs. A typical example is to use it as the request
// or the response type of an API method. For instance:
//
// service Foo {
// rpc Bar(google.protobuf.Empty) returns (google.protobuf.Empty);
// }
//
// The JSON representation for `Empty` is empty JSON object `{}`.
message Empty {}

338
vendor/github.com/golang/protobuf/ptypes/struct/struct.pb.go generated vendored
View file

@ -1,338 +0,0 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
// source: google/protobuf/struct.proto
package structpb
import (
fmt "fmt"
proto "github.com/golang/protobuf/proto"
math "math"
)
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf
// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.ProtoPackageIsVersion3 // please upgrade the proto package
// `NullValue` is a singleton enumeration to represent the null value for the
// `Value` type union.
//
// The JSON representation for `NullValue` is JSON `null`.
type NullValue int32
const (
// Null value.
NullValue_NULL_VALUE NullValue = 0
)
var NullValue_name = map[int32]string{
0: "NULL_VALUE",
}
var NullValue_value = map[string]int32{
"NULL_VALUE": 0,
}
func (x NullValue) String() string {
return proto.EnumName(NullValue_name, int32(x))
}
func (NullValue) EnumDescriptor() ([]byte, []int) {
return fileDescriptor_df322afd6c9fb402, []int{0}
}
func (NullValue) XXX_WellKnownType() string { return "NullValue" }
// `Struct` represents a structured data value, consisting of fields
// which map to dynamically typed values. In some languages, `Struct`
// might be supported by a native representation. For example, in
// scripting languages like JS a struct is represented as an
// object. The details of that representation are described together
// with the proto support for the language.
//
// The JSON representation for `Struct` is JSON object.
type Struct struct {
// Unordered map of dynamically typed values.
Fields map[string]*Value `protobuf:"bytes,1,rep,name=fields,proto3" json:"fields,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *Struct) Reset() { *m = Struct{} }
func (m *Struct) String() string { return proto.CompactTextString(m) }
func (*Struct) ProtoMessage() {}
func (*Struct) Descriptor() ([]byte, []int) {
return fileDescriptor_df322afd6c9fb402, []int{0}
}
func (*Struct) XXX_WellKnownType() string { return "Struct" }
func (m *Struct) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_Struct.Unmarshal(m, b)
}
func (m *Struct) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_Struct.Marshal(b, m, deterministic)
}
func (m *Struct) XXX_Merge(src proto.Message) {
xxx_messageInfo_Struct.Merge(m, src)
}
func (m *Struct) XXX_Size() int {
return xxx_messageInfo_Struct.Size(m)
}
func (m *Struct) XXX_DiscardUnknown() {
xxx_messageInfo_Struct.DiscardUnknown(m)
}
var xxx_messageInfo_Struct proto.InternalMessageInfo
func (m *Struct) GetFields() map[string]*Value {
if m != nil {
return m.Fields
}
return nil
}
// `Value` represents a dynamically typed value which can be either
// null, a number, a string, a boolean, a recursive struct value, or a
// list of values. A producer of value is expected to set one of that
// variants, absence of any variant indicates an error.
//
// The JSON representation for `Value` is JSON value.
type Value struct {
// The kind of value.
//
// Types that are valid to be assigned to Kind:
// *Value_NullValue
// *Value_NumberValue
// *Value_StringValue
// *Value_BoolValue
// *Value_StructValue
// *Value_ListValue
Kind isValue_Kind `protobuf_oneof:"kind"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *Value) Reset() { *m = Value{} }
func (m *Value) String() string { return proto.CompactTextString(m) }
func (*Value) ProtoMessage() {}
func (*Value) Descriptor() ([]byte, []int) {
return fileDescriptor_df322afd6c9fb402, []int{1}
}
func (*Value) XXX_WellKnownType() string { return "Value" }
func (m *Value) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_Value.Unmarshal(m, b)
}
func (m *Value) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_Value.Marshal(b, m, deterministic)
}
func (m *Value) XXX_Merge(src proto.Message) {
xxx_messageInfo_Value.Merge(m, src)
}
func (m *Value) XXX_Size() int {
return xxx_messageInfo_Value.Size(m)
}
func (m *Value) XXX_DiscardUnknown() {
xxx_messageInfo_Value.DiscardUnknown(m)
}
var xxx_messageInfo_Value proto.InternalMessageInfo
type isValue_Kind interface {
isValue_Kind()
}
type Value_NullValue struct {
NullValue NullValue `protobuf:"varint,1,opt,name=null_value,json=nullValue,proto3,enum=google.protobuf.NullValue,oneof"`
}
type Value_NumberValue struct {
NumberValue float64 `protobuf:"fixed64,2,opt,name=number_value,json=numberValue,proto3,oneof"`
}
type Value_StringValue struct {
StringValue string `protobuf:"bytes,3,opt,name=string_value,json=stringValue,proto3,oneof"`
}
type Value_BoolValue struct {
BoolValue bool `protobuf:"varint,4,opt,name=bool_value,json=boolValue,proto3,oneof"`
}
type Value_StructValue struct {
StructValue *Struct `protobuf:"bytes,5,opt,name=struct_value,json=structValue,proto3,oneof"`
}
type Value_ListValue struct {
ListValue *ListValue `protobuf:"bytes,6,opt,name=list_value,json=listValue,proto3,oneof"`
}
func (*Value_NullValue) isValue_Kind() {}
func (*Value_NumberValue) isValue_Kind() {}
func (*Value_StringValue) isValue_Kind() {}
func (*Value_BoolValue) isValue_Kind() {}
func (*Value_StructValue) isValue_Kind() {}
func (*Value_ListValue) isValue_Kind() {}
func (m *Value) GetKind() isValue_Kind {
if m != nil {
return m.Kind
}
return nil
}
func (m *Value) GetNullValue() NullValue {
if x, ok := m.GetKind().(*Value_NullValue); ok {
return x.NullValue
}
return NullValue_NULL_VALUE
}
func (m *Value) GetNumberValue() float64 {
if x, ok := m.GetKind().(*Value_NumberValue); ok {
return x.NumberValue
}
return 0
}
func (m *Value) GetStringValue() string {
if x, ok := m.GetKind().(*Value_StringValue); ok {
return x.StringValue
}
return ""
}
func (m *Value) GetBoolValue() bool {
if x, ok := m.GetKind().(*Value_BoolValue); ok {
return x.BoolValue
}
return false
}
func (m *Value) GetStructValue() *Struct {
if x, ok := m.GetKind().(*Value_StructValue); ok {
return x.StructValue
}
return nil
}
func (m *Value) GetListValue() *ListValue {
if x, ok := m.GetKind().(*Value_ListValue); ok {
return x.ListValue
}
return nil
}
// XXX_OneofWrappers is for the internal use of the proto package.
func (*Value) XXX_OneofWrappers() []interface{} {
return []interface{}{
(*Value_NullValue)(nil),
(*Value_NumberValue)(nil),
(*Value_StringValue)(nil),
(*Value_BoolValue)(nil),
(*Value_StructValue)(nil),
(*Value_ListValue)(nil),
}
}
// `ListValue` is a wrapper around a repeated field of values.
//
// The JSON representation for `ListValue` is JSON array.
type ListValue struct {
// Repeated field of dynamically typed values.
Values []*Value `protobuf:"bytes,1,rep,name=values,proto3" json:"values,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *ListValue) Reset() { *m = ListValue{} }
func (m *ListValue) String() string { return proto.CompactTextString(m) }
func (*ListValue) ProtoMessage() {}
func (*ListValue) Descriptor() ([]byte, []int) {
return fileDescriptor_df322afd6c9fb402, []int{2}
}
func (*ListValue) XXX_WellKnownType() string { return "ListValue" }
func (m *ListValue) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_ListValue.Unmarshal(m, b)
}
func (m *ListValue) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_ListValue.Marshal(b, m, deterministic)
}
func (m *ListValue) XXX_Merge(src proto.Message) {
xxx_messageInfo_ListValue.Merge(m, src)
}
func (m *ListValue) XXX_Size() int {
return xxx_messageInfo_ListValue.Size(m)
}
func (m *ListValue) XXX_DiscardUnknown() {
xxx_messageInfo_ListValue.DiscardUnknown(m)
}
var xxx_messageInfo_ListValue proto.InternalMessageInfo
func (m *ListValue) GetValues() []*Value {
if m != nil {
return m.Values
}
return nil
}
func init() {
proto.RegisterEnum("google.protobuf.NullValue", NullValue_name, NullValue_value)
proto.RegisterType((*Struct)(nil), "google.protobuf.Struct")
proto.RegisterMapType((map[string]*Value)(nil), "google.protobuf.Struct.FieldsEntry")
proto.RegisterType((*Value)(nil), "google.protobuf.Value")
proto.RegisterType((*ListValue)(nil), "google.protobuf.ListValue")
}
func init() {
proto.RegisterFile("google/protobuf/struct.proto", fileDescriptor_df322afd6c9fb402)
}
var fileDescriptor_df322afd6c9fb402 = []byte{
// 417 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x74, 0x92, 0x41, 0x8b, 0xd3, 0x40,
0x14, 0xc7, 0x3b, 0xc9, 0x36, 0x98, 0x17, 0x59, 0x97, 0x11, 0xb4, 0xac, 0xa2, 0xa1, 0x7b, 0x09,
0x22, 0x29, 0xd6, 0x8b, 0x18, 0x2f, 0x06, 0xd6, 0x5d, 0x30, 0x2c, 0x31, 0xba, 0x15, 0xbc, 0x94,
0x26, 0x4d, 0x63, 0xe8, 0x74, 0x26, 0x24, 0x33, 0x4a, 0x8f, 0x7e, 0x0b, 0xcf, 0x1e, 0x3d, 0xfa,
0xe9, 0x3c, 0xca, 0xcc, 0x24, 0xa9, 0xb4, 0xf4, 0x94, 0xbc, 0xf7, 0x7e, 0xef, 0x3f, 0xef, 0xff,
0x66, 0xe0, 0x71, 0xc1, 0x58, 0x41, 0xf2, 0x49, 0x55, 0x33, 0xce, 0x52, 0xb1, 0x9a, 0x34, 0xbc,
0x16, 0x19, 0xf7, 0x55, 0x8c, 0xef, 0xe9, 0xaa, 0xdf, 0x55, 0xc7, 0x3f, 0x11, 0x58, 0x1f, 0x15,
0x81, 0x03, 0xb0, 0x56, 0x65, 0x4e, 0x96, 0xcd, 0x08, 0xb9, 0xa6, 0xe7, 0x4c, 0x2f, 0xfc, 0x3d,
0xd8, 0xd7, 0xa0, 0xff, 0x4e, 0x51, 0x97, 0x94, 0xd7, 0xdb, 0xa4, 0x6d, 0x39, 0xff, 0x00, 0xce,
0x7f, 0x69, 0x7c, 0x06, 0xe6, 0x3a, 0xdf, 0x8e, 0x90, 0x8b, 0x3c, 0x3b, 0x91, 0xbf, 0xf8, 0x39,
0x0c, 0xbf, 0x2d, 0x88, 0xc8, 0x47, 0x86, 0x8b, 0x3c, 0x67, 0xfa, 0xe0, 0x40, 0x7c, 0x26, 0xab,
0x89, 0x86, 0x5e, 0x1b, 0xaf, 0xd0, 0xf8, 0x8f, 0x01, 0x43, 0x95, 0xc4, 0x01, 0x00, 0x15, 0x84,
0xcc, 0xb5, 0x80, 0x14, 0x3d, 0x9d, 0x9e, 0x1f, 0x08, 0xdc, 0x08, 0x42, 0x14, 0x7f, 0x3d, 0x48,
0x6c, 0xda, 0x05, 0xf8, 0x02, 0xee, 0x52, 0xb1, 0x49, 0xf3, 0x7a, 0xbe, 0x3b, 0x1f, 0x5d, 0x0f,
0x12, 0x47, 0x67, 0x7b, 0xa8, 0xe1, 0x75, 0x49, 0x8b, 0x16, 0x32, 0xe5, 0xe0, 0x12, 0xd2, 0x59,
0x0d, 0x3d, 0x05, 0x48, 0x19, 0xeb, 0xc6, 0x38, 0x71, 0x91, 0x77, 0x47, 0x1e, 0x25, 0x73, 0x1a,
0x78, 0xa3, 0x54, 0x44, 0xc6, 0x5b, 0x64, 0xa8, 0xac, 0x3e, 0x3c, 0xb2, 0xc7, 0x56, 0x5e, 0x64,
0xbc, 0x77, 0x49, 0xca, 0xa6, 0xeb, 0xb5, 0x54, 0xef, 0xa1, 0xcb, 0xa8, 0x6c, 0x78, 0xef, 0x92,
0x74, 0x41, 0x68, 0xc1, 0xc9, 0xba, 0xa4, 0xcb, 0x71, 0x00, 0x76, 0x4f, 0x60, 0x1f, 0x2c, 0x25,
0xd6, 0xdd, 0xe8, 0xb1, 0xa5, 0xb7, 0xd4, 0xb3, 0x47, 0x60, 0xf7, 0x4b, 0xc4, 0xa7, 0x00, 0x37,
0xb7, 0x51, 0x34, 0x9f, 0xbd, 0x8d, 0x6e, 0x2f, 0xcf, 0x06, 0xe1, 0x0f, 0x04, 0xf7, 0x33, 0xb6,
0xd9, 0x97, 0x08, 0x1d, 0xed, 0x26, 0x96, 0x71, 0x8c, 0xbe, 0xbc, 0x28, 0x4a, 0xfe, 0x55, 0xa4,
0x7e, 0xc6, 0x36, 0x93, 0x82, 0x91, 0x05, 0x2d, 0x76, 0x4f, 0xb1, 0xe2, 0xdb, 0x2a, 0x6f, 0xda,
0x17, 0x19, 0xe8, 0x4f, 0x95, 0xfe, 0x45, 0xe8, 0x97, 0x61, 0x5e, 0xc5, 0xe1, 0x6f, 0xe3, 0xc9,
0x95, 0x16, 0x8f, 0xbb, 0xf9, 0x3e, 0xe7, 0x84, 0xbc, 0xa7, 0xec, 0x3b, 0xfd, 0x24, 0x3b, 0x53,
0x4b, 0x49, 0xbd, 0xfc, 0x17, 0x00, 0x00, 0xff, 0xff, 0xe8, 0x1b, 0x59, 0xf8, 0xe5, 0x02, 0x00,
0x00,
}

95
vendor/github.com/golang/protobuf/ptypes/struct/struct.proto generated vendored
View file

@ -1,95 +0,0 @@
// Protocol Buffers - Google's data interchange format
// Copyright 2008 Google Inc. All rights reserved.
// https://developers.google.com/protocol-buffers/
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
// * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
// * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following disclaimer
// in the documentation and/or other materials provided with the
// distribution.
// * Neither the name of Google Inc. nor the names of its
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
syntax = "proto3";
package google.protobuf;
option csharp_namespace = "Google.Protobuf.WellKnownTypes";
option cc_enable_arenas = true;
option go_package = "github.com/golang/protobuf/ptypes/struct;structpb";
option java_package = "com.google.protobuf";
option java_outer_classname = "StructProto";
option java_multiple_files = true;
option objc_class_prefix = "GPB";
// `Struct` represents a structured data value, consisting of fields
// which map to dynamically typed values. In some languages, `Struct`
// might be supported by a native representation. For example, in
// scripting languages like JS a struct is represented as an
// object. The details of that representation are described together
// with the proto support for the language.
//
// The JSON representation for `Struct` is JSON object.
message Struct {
// Unordered map of dynamically typed values.
map<string, Value> fields = 1;
}
// `Value` represents a dynamically typed value which can be either
// null, a number, a string, a boolean, a recursive struct value, or a
// list of values. A producer of value is expected to set one of that
// variants, absence of any variant indicates an error.
//
// The JSON representation for `Value` is JSON value.
message Value {
// The kind of value.
oneof kind {
// Represents a null value.
NullValue null_value = 1;
// Represents a double value.
double number_value = 2;
// Represents a string value.
string string_value = 3;
// Represents a boolean value.
bool bool_value = 4;
// Represents a structured value.
Struct struct_value = 5;
// Represents a repeated `Value`.
ListValue list_value = 6;
}
}
// `NullValue` is a singleton enumeration to represent the null value for the
// `Value` type union.
//
// The JSON representation for `NullValue` is JSON `null`.
enum NullValue {
// Null value.
NULL_VALUE = 0;
}
// `ListValue` is a wrapper around a repeated field of values.
//
// The JSON representation for `ListValue` is JSON array.
message ListValue {
// Repeated field of dynamically typed values.
repeated Value values = 1;
}

161
vendor/github.com/golang/protobuf/ptypes/timestamp.go generated vendored
View file

@ -1,46 +1,18 @@
// Go support for Protocol Buffers - Google's data interchange format
//
// Copyright 2016 The Go Authors. All rights reserved.
// https://github.com/golang/protobuf
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
// * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
// * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following disclaimer
// in the documentation and/or other materials provided with the
// distribution.
// * Neither the name of Google Inc. nor the names of its
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
// Copyright 2016 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
package ptypes
// This file implements operations on google.protobuf.Timestamp.
import (
"errors"
"fmt"
"time"
tspb "github.com/golang/protobuf/ptypes/timestamp"
timestamppb "github.com/golang/protobuf/ptypes/timestamp"
)
// Range of google.protobuf.Duration as specified in timestamp.proto.
const (
// Seconds field of the earliest valid Timestamp.
// This is time.Date(1, 1, 1, 0, 0, 0, 0, time.UTC).Unix().
@ -50,17 +22,71 @@ const (
maxValidSeconds = 253402300800
)
// Timestamp converts a timestamppb.Timestamp to a time.Time.
// It returns an error if the argument is invalid.
//
// Unlike most Go functions, if Timestamp returns an error, the first return
// value is not the zero time.Time. Instead, it is the value obtained from the
// time.Unix function when passed the contents of the Timestamp, in the UTC
// locale. This may or may not be a meaningful time; many invalid Timestamps
// do map to valid time.Times.
//
// A nil Timestamp returns an error. The first return value in that case is
// undefined.
func Timestamp(ts *timestamppb.Timestamp) (time.Time, error) {
// Don't return the zero value on error, because corresponds to a valid
// timestamp. Instead return whatever time.Unix gives us.
var t time.Time
if ts == nil {
t = time.Unix(0, 0).UTC() // treat nil like the empty Timestamp
} else {
t = time.Unix(ts.Seconds, int64(ts.Nanos)).UTC()
}
return t, validateTimestamp(ts)
}
// TimestampNow returns a google.protobuf.Timestamp for the current time.
func TimestampNow() *timestamppb.Timestamp {
ts, err := TimestampProto(time.Now())
if err != nil {
panic("ptypes: time.Now() out of Timestamp range")
}
return ts
}
// TimestampProto converts the time.Time to a google.protobuf.Timestamp proto.
// It returns an error if the resulting Timestamp is invalid.
func TimestampProto(t time.Time) (*timestamppb.Timestamp, error) {
ts := &timestamppb.Timestamp{
Seconds: t.Unix(),
Nanos: int32(t.Nanosecond()),
}
if err := validateTimestamp(ts); err != nil {
return nil, err
}
return ts, nil
}
// TimestampString returns the RFC 3339 string for valid Timestamps.
// For invalid Timestamps, it returns an error message in parentheses.
func TimestampString(ts *timestamppb.Timestamp) string {
t, err := Timestamp(ts)
if err != nil {
return fmt.Sprintf("(%v)", err)
}
return t.Format(time.RFC3339Nano)
}
// validateTimestamp determines whether a Timestamp is valid.
// A valid timestamp represents a time in the range
// [0001-01-01, 10000-01-01) and has a Nanos field
// in the range [0, 1e9).
// A valid timestamp represents a time in the range [0001-01-01, 10000-01-01)
// and has a Nanos field in the range [0, 1e9).
//
// If the Timestamp is valid, validateTimestamp returns nil.
// Otherwise, it returns an error that describes
// the problem.
// Otherwise, it returns an error that describes the problem.
//
// Every valid Timestamp can be represented by a time.Time, but the converse is not true.
func validateTimestamp(ts *tspb.Timestamp) error {
// Every valid Timestamp can be represented by a time.Time,
// but the converse is not true.
func validateTimestamp(ts *timestamppb.Timestamp) error {
if ts == nil {
return errors.New("timestamp: nil Timestamp")
}
@ -75,58 +101,3 @@ func validateTimestamp(ts *tspb.Timestamp) error {
}
return nil
}
// Timestamp converts a google.protobuf.Timestamp proto to a time.Time.
// It returns an error if the argument is invalid.
//
// Unlike most Go functions, if Timestamp returns an error, the first return value
// is not the zero time.Time. Instead, it is the value obtained from the
// time.Unix function when passed the contents of the Timestamp, in the UTC
// locale. This may or may not be a meaningful time; many invalid Timestamps
// do map to valid time.Times.
//
// A nil Timestamp returns an error. The first return value in that case is
// undefined.
func Timestamp(ts *tspb.Timestamp) (time.Time, error) {
// Don't return the zero value on error, because corresponds to a valid
// timestamp. Instead return whatever time.Unix gives us.
var t time.Time
if ts == nil {
t = time.Unix(0, 0).UTC() // treat nil like the empty Timestamp
} else {
t = time.Unix(ts.Seconds, int64(ts.Nanos)).UTC()
}
return t, validateTimestamp(ts)
}
// TimestampNow returns a google.protobuf.Timestamp for the current time.
func TimestampNow() *tspb.Timestamp {
ts, err := TimestampProto(time.Now())
if err != nil {
panic("ptypes: time.Now() out of Timestamp range")
}
return ts
}
// TimestampProto converts the time.Time to a google.protobuf.Timestamp proto.
// It returns an error if the resulting Timestamp is invalid.
func TimestampProto(t time.Time) (*tspb.Timestamp, error) {
ts := &tspb.Timestamp{
Seconds: t.Unix(),
Nanos: int32(t.Nanosecond()),
}
if err := validateTimestamp(ts); err != nil {
return nil, err
}
return ts, nil
}
// TimestampString returns the RFC 3339 string for valid Timestamps. For invalid
// Timestamps, it returns an error message in parentheses.
func TimestampString(ts *tspb.Timestamp) string {
t, err := Timestamp(ts)
if err != nil {
return fmt.Sprintf("(%v)", err)
}
return t.Format(time.RFC3339Nano)
}

219
vendor/github.com/golang/protobuf/ptypes/timestamp/timestamp.pb.go generated vendored
View file

@ -1,185 +1,64 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
// source: google/protobuf/timestamp.proto
// source: github.com/golang/protobuf/ptypes/timestamp/timestamp.proto
package timestamp
import (
fmt "fmt"
proto "github.com/golang/protobuf/proto"
math "math"
protoreflect "google.golang.org/protobuf/reflect/protoreflect"
protoimpl "google.golang.org/protobuf/runtime/protoimpl"
timestamppb "google.golang.org/protobuf/types/known/timestamppb"
reflect "reflect"
)
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf
// Symbols defined in public import of google/protobuf/timestamp.proto.
// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.ProtoPackageIsVersion3 // please upgrade the proto package
type Timestamp = timestamppb.Timestamp
// A Timestamp represents a point in time independent of any time zone or local
// calendar, encoded as a count of seconds and fractions of seconds at
// nanosecond resolution. The count is relative to an epoch at UTC midnight on
// January 1, 1970, in the proleptic Gregorian calendar which extends the
// Gregorian calendar backwards to year one.
//
// All minutes are 60 seconds long. Leap seconds are "smeared" so that no leap
// second table is needed for interpretation, using a [24-hour linear
// smear](https://developers.google.com/time/smear).
//
// The range is from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59.999999999Z. By
// restricting to that range, we ensure that we can convert to and from [RFC
// 3339](https://www.ietf.org/rfc/rfc3339.txt) date strings.
//
// # Examples
//
// Example 1: Compute Timestamp from POSIX `time()`.
//
// Timestamp timestamp;
// timestamp.set_seconds(time(NULL));
// timestamp.set_nanos(0);
//
// Example 2: Compute Timestamp from POSIX `gettimeofday()`.
//
// struct timeval tv;
// gettimeofday(&tv, NULL);
//
// Timestamp timestamp;
// timestamp.set_seconds(tv.tv_sec);
// timestamp.set_nanos(tv.tv_usec * 1000);
//
// Example 3: Compute Timestamp from Win32 `GetSystemTimeAsFileTime()`.
//
// FILETIME ft;
// GetSystemTimeAsFileTime(&ft);
// UINT64 ticks = (((UINT64)ft.dwHighDateTime) << 32) | ft.dwLowDateTime;
//
// // A Windows tick is 100 nanoseconds. Windows epoch 1601-01-01T00:00:00Z
// // is 11644473600 seconds before Unix epoch 1970-01-01T00:00:00Z.
// Timestamp timestamp;
// timestamp.set_seconds((INT64) ((ticks / 10000000) - 11644473600LL));
// timestamp.set_nanos((INT32) ((ticks % 10000000) * 100));
//
// Example 4: Compute Timestamp from Java `System.currentTimeMillis()`.
//
// long millis = System.currentTimeMillis();
//
// Timestamp timestamp = Timestamp.newBuilder().setSeconds(millis / 1000)
// .setNanos((int) ((millis % 1000) * 1000000)).build();
//
//
// Example 5: Compute Timestamp from current time in Python.
//
// timestamp = Timestamp()
// timestamp.GetCurrentTime()
//
// # JSON Mapping
//
// In JSON format, the Timestamp type is encoded as a string in the
// [RFC 3339](https://www.ietf.org/rfc/rfc3339.txt) format. That is, the
// format is "{year}-{month}-{day}T{hour}:{min}:{sec}[.{frac_sec}]Z"
// where {year} is always expressed using four digits while {month}, {day},
// {hour}, {min}, and {sec} are zero-padded to two digits each. The fractional
// seconds, which can go up to 9 digits (i.e. up to 1 nanosecond resolution),
// are optional. The "Z" suffix indicates the timezone ("UTC"); the timezone
// is required. A proto3 JSON serializer should always use UTC (as indicated by
// "Z") when printing the Timestamp type and a proto3 JSON parser should be
// able to accept both UTC and other timezones (as indicated by an offset).
//
// For example, "2017-01-15T01:30:15.01Z" encodes 15.01 seconds past
// 01:30 UTC on January 15, 2017.
//
// In JavaScript, one can convert a Date object to this format using the
// standard
// [toISOString()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toISOString)
// method. In Python, a standard `datetime.datetime` object can be converted
// to this format using
// [`strftime`](https://docs.python.org/2/library/time.html#time.strftime) with
// the time format spec '%Y-%m-%dT%H:%M:%S.%fZ'. Likewise, in Java, one can use
// the Joda Time's [`ISODateTimeFormat.dateTime()`](
// http://www.joda.org/joda-time/apidocs/org/joda/time/format/ISODateTimeFormat.html#dateTime%2D%2D
// ) to obtain a formatter capable of generating timestamps in this format.
//
//
type Timestamp struct {
// Represents seconds of UTC time since Unix epoch
// 1970-01-01T00:00:00Z. Must be from 0001-01-01T00:00:00Z to
// 9999-12-31T23:59:59Z inclusive.
Seconds int64 `protobuf:"varint,1,opt,name=seconds,proto3" json:"seconds,omitempty"`
// Non-negative fractions of a second at nanosecond resolution. Negative
// second values with fractions must still have non-negative nanos values
// that count forward in time. Must be from 0 to 999,999,999
// inclusive.
Nanos int32 `protobuf:"varint,2,opt,name=nanos,proto3" json:"nanos,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
var File_github_com_golang_protobuf_ptypes_timestamp_timestamp_proto protoreflect.FileDescriptor
var file_github_com_golang_protobuf_ptypes_timestamp_timestamp_proto_rawDesc = []byte{
0x0a, 0x3b, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x6f, 0x6c,
0x61, 0x6e, 0x67, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x70, 0x74, 0x79,
0x70, 0x65, 0x73, 0x2f, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x2f, 0x74, 0x69,
0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x1f, 0x67,
0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x74,
0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x42, 0x37,
0x5a, 0x35, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x6f, 0x6c,
0x61, 0x6e, 0x67, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x70, 0x74, 0x79,
0x70, 0x65, 0x73, 0x2f, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x3b, 0x74, 0x69,
0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x50, 0x00, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f,
0x33,
}
func (m *Timestamp) Reset() { *m = Timestamp{} }
func (m *Timestamp) String() string { return proto.CompactTextString(m) }
func (*Timestamp) ProtoMessage() {}
func (*Timestamp) Descriptor() ([]byte, []int) {
return fileDescriptor_292007bbfe81227e, []int{0}
var file_github_com_golang_protobuf_ptypes_timestamp_timestamp_proto_goTypes = []interface{}{}
var file_github_com_golang_protobuf_ptypes_timestamp_timestamp_proto_depIdxs = []int32{
0, // [0:0] is the sub-list for method output_type
0, // [0:0] is the sub-list for method input_type
0, // [0:0] is the sub-list for extension type_name
0, // [0:0] is the sub-list for extension extendee
0, // [0:0] is the sub-list for field type_name
}
func (*Timestamp) XXX_WellKnownType() string { return "Timestamp" }
func (m *Timestamp) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_Timestamp.Unmarshal(m, b)
}
func (m *Timestamp) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_Timestamp.Marshal(b, m, deterministic)
}
func (m *Timestamp) XXX_Merge(src proto.Message) {
xxx_messageInfo_Timestamp.Merge(m, src)
}
func (m *Timestamp) XXX_Size() int {
return xxx_messageInfo_Timestamp.Size(m)
}
func (m *Timestamp) XXX_DiscardUnknown() {
xxx_messageInfo_Timestamp.DiscardUnknown(m)
}
var xxx_messageInfo_Timestamp proto.InternalMessageInfo
func (m *Timestamp) GetSeconds() int64 {
if m != nil {
return m.Seconds
func init() { file_github_com_golang_protobuf_ptypes_timestamp_timestamp_proto_init() }
func file_github_com_golang_protobuf_ptypes_timestamp_timestamp_proto_init() {
if File_github_com_golang_protobuf_ptypes_timestamp_timestamp_proto != nil {
return
}
return 0
}
func (m *Timestamp) GetNanos() int32 {
if m != nil {
return m.Nanos
}
return 0
}
func init() {
proto.RegisterType((*Timestamp)(nil), "google.protobuf.Timestamp")
}
func init() {
proto.RegisterFile("google/protobuf/timestamp.proto", fileDescriptor_292007bbfe81227e)
}
var fileDescriptor_292007bbfe81227e = []byte{
// 191 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x92, 0x4f, 0xcf, 0xcf, 0x4f,
0xcf, 0x49, 0xd5, 0x2f, 0x28, 0xca, 0x2f, 0xc9, 0x4f, 0x2a, 0x4d, 0xd3, 0x2f, 0xc9, 0xcc, 0x4d,
0x2d, 0x2e, 0x49, 0xcc, 0x2d, 0xd0, 0x03, 0x0b, 0x09, 0xf1, 0x43, 0x14, 0xe8, 0xc1, 0x14, 0x28,
0x59, 0x73, 0x71, 0x86, 0xc0, 0xd4, 0x08, 0x49, 0x70, 0xb1, 0x17, 0xa7, 0x26, 0xe7, 0xe7, 0xa5,
0x14, 0x4b, 0x30, 0x2a, 0x30, 0x6a, 0x30, 0x07, 0xc1, 0xb8, 0x42, 0x22, 0x5c, 0xac, 0x79, 0x89,
0x79, 0xf9, 0xc5, 0x12, 0x4c, 0x0a, 0x8c, 0x1a, 0xac, 0x41, 0x10, 0x8e, 0x53, 0x1d, 0x97, 0x70,
0x72, 0x7e, 0xae, 0x1e, 0x9a, 0x99, 0x4e, 0x7c, 0x70, 0x13, 0x03, 0x40, 0x42, 0x01, 0x8c, 0x51,
0xda, 0xe9, 0x99, 0x25, 0x19, 0xa5, 0x49, 0x7a, 0xc9, 0xf9, 0xb9, 0xfa, 0xe9, 0xf9, 0x39, 0x89,
0x79, 0xe9, 0x08, 0x27, 0x16, 0x94, 0x54, 0x16, 0xa4, 0x16, 0x23, 0x5c, 0xfa, 0x83, 0x91, 0x71,
0x11, 0x13, 0xb3, 0x7b, 0x80, 0xd3, 0x2a, 0x26, 0x39, 0x77, 0x88, 0xc9, 0x01, 0x50, 0xb5, 0x7a,
0xe1, 0xa9, 0x39, 0x39, 0xde, 0x79, 0xf9, 0xe5, 0x79, 0x21, 0x20, 0x3d, 0x49, 0x6c, 0x60, 0x43,
0x8c, 0x01, 0x01, 0x00, 0x00, 0xff, 0xff, 0xbc, 0x77, 0x4a, 0x07, 0xf7, 0x00, 0x00, 0x00,
type x struct{}
out := protoimpl.TypeBuilder{
File: protoimpl.DescBuilder{
GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
RawDescriptor: file_github_com_golang_protobuf_ptypes_timestamp_timestamp_proto_rawDesc,
NumEnums: 0,
NumMessages: 0,
NumExtensions: 0,
NumServices: 0,
},
GoTypes: file_github_com_golang_protobuf_ptypes_timestamp_timestamp_proto_goTypes,
DependencyIndexes: file_github_com_golang_protobuf_ptypes_timestamp_timestamp_proto_depIdxs,
}.Build()
File_github_com_golang_protobuf_ptypes_timestamp_timestamp_proto = out.File
file_github_com_golang_protobuf_ptypes_timestamp_timestamp_proto_rawDesc = nil
file_github_com_golang_protobuf_ptypes_timestamp_timestamp_proto_goTypes = nil
file_github_com_golang_protobuf_ptypes_timestamp_timestamp_proto_depIdxs = nil
}

138
vendor/github.com/golang/protobuf/ptypes/timestamp/timestamp.proto generated vendored
View file

@ -1,138 +0,0 @@
// Protocol Buffers - Google's data interchange format
// Copyright 2008 Google Inc. All rights reserved.
// https://developers.google.com/protocol-buffers/
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
// * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
// * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following disclaimer
// in the documentation and/or other materials provided with the
// distribution.
// * Neither the name of Google Inc. nor the names of its
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
syntax = "proto3";
package google.protobuf;
option csharp_namespace = "Google.Protobuf.WellKnownTypes";
option cc_enable_arenas = true;
option go_package = "github.com/golang/protobuf/ptypes/timestamp";
option java_package = "com.google.protobuf";
option java_outer_classname = "TimestampProto";
option java_multiple_files = true;
option objc_class_prefix = "GPB";
// A Timestamp represents a point in time independent of any time zone or local
// calendar, encoded as a count of seconds and fractions of seconds at
// nanosecond resolution. The count is relative to an epoch at UTC midnight on
// January 1, 1970, in the proleptic Gregorian calendar which extends the
// Gregorian calendar backwards to year one.
//
// All minutes are 60 seconds long. Leap seconds are "smeared" so that no leap
// second table is needed for interpretation, using a [24-hour linear
// smear](https://developers.google.com/time/smear).
//
// The range is from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59.999999999Z. By
// restricting to that range, we ensure that we can convert to and from [RFC
// 3339](https://www.ietf.org/rfc/rfc3339.txt) date strings.
//
// # Examples
//
// Example 1: Compute Timestamp from POSIX `time()`.
//
// Timestamp timestamp;
// timestamp.set_seconds(time(NULL));
// timestamp.set_nanos(0);
//
// Example 2: Compute Timestamp from POSIX `gettimeofday()`.
//
// struct timeval tv;
// gettimeofday(&tv, NULL);
//
// Timestamp timestamp;
// timestamp.set_seconds(tv.tv_sec);
// timestamp.set_nanos(tv.tv_usec * 1000);
//
// Example 3: Compute Timestamp from Win32 `GetSystemTimeAsFileTime()`.
//
// FILETIME ft;
// GetSystemTimeAsFileTime(&ft);
// UINT64 ticks = (((UINT64)ft.dwHighDateTime) << 32) | ft.dwLowDateTime;
//
// // A Windows tick is 100 nanoseconds. Windows epoch 1601-01-01T00:00:00Z
// // is 11644473600 seconds before Unix epoch 1970-01-01T00:00:00Z.
// Timestamp timestamp;
// timestamp.set_seconds((INT64) ((ticks / 10000000) - 11644473600LL));
// timestamp.set_nanos((INT32) ((ticks % 10000000) * 100));
//
// Example 4: Compute Timestamp from Java `System.currentTimeMillis()`.
//
// long millis = System.currentTimeMillis();
//
// Timestamp timestamp = Timestamp.newBuilder().setSeconds(millis / 1000)
// .setNanos((int) ((millis % 1000) * 1000000)).build();
//
//
// Example 5: Compute Timestamp from current time in Python.
//
// timestamp = Timestamp()
// timestamp.GetCurrentTime()
//
// # JSON Mapping
//
// In JSON format, the Timestamp type is encoded as a string in the
// [RFC 3339](https://www.ietf.org/rfc/rfc3339.txt) format. That is, the
// format is "{year}-{month}-{day}T{hour}:{min}:{sec}[.{frac_sec}]Z"
// where {year} is always expressed using four digits while {month}, {day},
// {hour}, {min}, and {sec} are zero-padded to two digits each. The fractional
// seconds, which can go up to 9 digits (i.e. up to 1 nanosecond resolution),
// are optional. The "Z" suffix indicates the timezone ("UTC"); the timezone
// is required. A proto3 JSON serializer should always use UTC (as indicated by
// "Z") when printing the Timestamp type and a proto3 JSON parser should be
// able to accept both UTC and other timezones (as indicated by an offset).
//
// For example, "2017-01-15T01:30:15.01Z" encodes 15.01 seconds past
// 01:30 UTC on January 15, 2017.
//
// In JavaScript, one can convert a Date object to this format using the
// standard
// [toISOString()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toISOString)
// method. In Python, a standard `datetime.datetime` object can be converted
// to this format using
// [`strftime`](https://docs.python.org/2/library/time.html#time.strftime) with
// the time format spec '%Y-%m-%dT%H:%M:%S.%fZ'. Likewise, in Java, one can use
// the Joda Time's [`ISODateTimeFormat.dateTime()`](
// http://www.joda.org/joda-time/apidocs/org/joda/time/format/ISODateTimeFormat.html#dateTime%2D%2D
// ) to obtain a formatter capable of generating timestamps in this format.
//
//
message Timestamp {
// Represents seconds of UTC time since Unix epoch
// 1970-01-01T00:00:00Z. Must be from 0001-01-01T00:00:00Z to
// 9999-12-31T23:59:59Z inclusive.
int64 seconds = 1;
// Non-negative fractions of a second at nanosecond resolution. Negative
// second values with fractions must still have non-negative nanos values
// that count forward in time. Must be from 0 to 999,999,999
// inclusive.
int32 nanos = 2;
}

504
vendor/github.com/golang/protobuf/ptypes/wrappers/wrappers.pb.go generated vendored
View file

@ -1,463 +1,71 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
// source: google/protobuf/wrappers.proto
// source: github.com/golang/protobuf/ptypes/wrappers/wrappers.proto
package wrappers
import (
fmt "fmt"
proto "github.com/golang/protobuf/proto"
math "math"
protoreflect "google.golang.org/protobuf/reflect/protoreflect"
protoimpl "google.golang.org/protobuf/runtime/protoimpl"
wrapperspb "google.golang.org/protobuf/types/known/wrapperspb"
reflect "reflect"
)
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf
// Symbols defined in public import of google/protobuf/wrappers.proto.
// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.ProtoPackageIsVersion3 // please upgrade the proto package
type DoubleValue = wrapperspb.DoubleValue
type FloatValue = wrapperspb.FloatValue
type Int64Value = wrapperspb.Int64Value
type UInt64Value = wrapperspb.UInt64Value
type Int32Value = wrapperspb.Int32Value
type UInt32Value = wrapperspb.UInt32Value
type BoolValue = wrapperspb.BoolValue
type StringValue = wrapperspb.StringValue
type BytesValue = wrapperspb.BytesValue
// Wrapper message for `double`.
//
// The JSON representation for `DoubleValue` is JSON number.
type DoubleValue struct {
// The double value.
Value float64 `protobuf:"fixed64,1,opt,name=value,proto3" json:"value,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
var File_github_com_golang_protobuf_ptypes_wrappers_wrappers_proto protoreflect.FileDescriptor
var file_github_com_golang_protobuf_ptypes_wrappers_wrappers_proto_rawDesc = []byte{
0x0a, 0x39, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x6f, 0x6c,
0x61, 0x6e, 0x67, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x70, 0x74, 0x79,
0x70, 0x65, 0x73, 0x2f, 0x77, 0x72, 0x61, 0x70, 0x70, 0x65, 0x72, 0x73, 0x2f, 0x77, 0x72, 0x61,
0x70, 0x70, 0x65, 0x72, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x1e, 0x67, 0x6f, 0x6f,
0x67, 0x6c, 0x65, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x77, 0x72, 0x61,
0x70, 0x70, 0x65, 0x72, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x42, 0x35, 0x5a, 0x33, 0x67,
0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x6f, 0x6c, 0x61, 0x6e, 0x67,
0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x70, 0x74, 0x79, 0x70, 0x65, 0x73,
0x2f, 0x77, 0x72, 0x61, 0x70, 0x70, 0x65, 0x72, 0x73, 0x3b, 0x77, 0x72, 0x61, 0x70, 0x70, 0x65,
0x72, 0x73, 0x50, 0x00, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
}
func (m *DoubleValue) Reset() { *m = DoubleValue{} }
func (m *DoubleValue) String() string { return proto.CompactTextString(m) }
func (*DoubleValue) ProtoMessage() {}
func (*DoubleValue) Descriptor() ([]byte, []int) {
return fileDescriptor_5377b62bda767935, []int{0}
var file_github_com_golang_protobuf_ptypes_wrappers_wrappers_proto_goTypes = []interface{}{}
var file_github_com_golang_protobuf_ptypes_wrappers_wrappers_proto_depIdxs = []int32{
0, // [0:0] is the sub-list for method output_type
0, // [0:0] is the sub-list for method input_type
0, // [0:0] is the sub-list for extension type_name
0, // [0:0] is the sub-list for extension extendee
0, // [0:0] is the sub-list for field type_name
}
func (*DoubleValue) XXX_WellKnownType() string { return "DoubleValue" }
func (m *DoubleValue) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_DoubleValue.Unmarshal(m, b)
}
func (m *DoubleValue) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_DoubleValue.Marshal(b, m, deterministic)
}
func (m *DoubleValue) XXX_Merge(src proto.Message) {
xxx_messageInfo_DoubleValue.Merge(m, src)
}
func (m *DoubleValue) XXX_Size() int {
return xxx_messageInfo_DoubleValue.Size(m)
}
func (m *DoubleValue) XXX_DiscardUnknown() {
xxx_messageInfo_DoubleValue.DiscardUnknown(m)
}
var xxx_messageInfo_DoubleValue proto.InternalMessageInfo
func (m *DoubleValue) GetValue() float64 {
if m != nil {
return m.Value
func init() { file_github_com_golang_protobuf_ptypes_wrappers_wrappers_proto_init() }
func file_github_com_golang_protobuf_ptypes_wrappers_wrappers_proto_init() {
if File_github_com_golang_protobuf_ptypes_wrappers_wrappers_proto != nil {
return
}
return 0
}
// Wrapper message for `float`.
//
// The JSON representation for `FloatValue` is JSON number.
type FloatValue struct {
// The float value.
Value float32 `protobuf:"fixed32,1,opt,name=value,proto3" json:"value,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *FloatValue) Reset() { *m = FloatValue{} }
func (m *FloatValue) String() string { return proto.CompactTextString(m) }
func (*FloatValue) ProtoMessage() {}
func (*FloatValue) Descriptor() ([]byte, []int) {
return fileDescriptor_5377b62bda767935, []int{1}
}
func (*FloatValue) XXX_WellKnownType() string { return "FloatValue" }
func (m *FloatValue) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_FloatValue.Unmarshal(m, b)
}
func (m *FloatValue) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_FloatValue.Marshal(b, m, deterministic)
}
func (m *FloatValue) XXX_Merge(src proto.Message) {
xxx_messageInfo_FloatValue.Merge(m, src)
}
func (m *FloatValue) XXX_Size() int {
return xxx_messageInfo_FloatValue.Size(m)
}
func (m *FloatValue) XXX_DiscardUnknown() {
xxx_messageInfo_FloatValue.DiscardUnknown(m)
}
var xxx_messageInfo_FloatValue proto.InternalMessageInfo
func (m *FloatValue) GetValue() float32 {
if m != nil {
return m.Value
}
return 0
}
// Wrapper message for `int64`.
//
// The JSON representation for `Int64Value` is JSON string.
type Int64Value struct {
// The int64 value.
Value int64 `protobuf:"varint,1,opt,name=value,proto3" json:"value,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *Int64Value) Reset() { *m = Int64Value{} }
func (m *Int64Value) String() string { return proto.CompactTextString(m) }
func (*Int64Value) ProtoMessage() {}
func (*Int64Value) Descriptor() ([]byte, []int) {
return fileDescriptor_5377b62bda767935, []int{2}
}
func (*Int64Value) XXX_WellKnownType() string { return "Int64Value" }
func (m *Int64Value) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_Int64Value.Unmarshal(m, b)
}
func (m *Int64Value) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_Int64Value.Marshal(b, m, deterministic)
}
func (m *Int64Value) XXX_Merge(src proto.Message) {
xxx_messageInfo_Int64Value.Merge(m, src)
}
func (m *Int64Value) XXX_Size() int {
return xxx_messageInfo_Int64Value.Size(m)
}
func (m *Int64Value) XXX_DiscardUnknown() {
xxx_messageInfo_Int64Value.DiscardUnknown(m)
}
var xxx_messageInfo_Int64Value proto.InternalMessageInfo
func (m *Int64Value) GetValue() int64 {
if m != nil {
return m.Value
}
return 0
}
// Wrapper message for `uint64`.
//
// The JSON representation for `UInt64Value` is JSON string.
type UInt64Value struct {
// The uint64 value.
Value uint64 `protobuf:"varint,1,opt,name=value,proto3" json:"value,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *UInt64Value) Reset() { *m = UInt64Value{} }
func (m *UInt64Value) String() string { return proto.CompactTextString(m) }
func (*UInt64Value) ProtoMessage() {}
func (*UInt64Value) Descriptor() ([]byte, []int) {
return fileDescriptor_5377b62bda767935, []int{3}
}
func (*UInt64Value) XXX_WellKnownType() string { return "UInt64Value" }
func (m *UInt64Value) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_UInt64Value.Unmarshal(m, b)
}
func (m *UInt64Value) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_UInt64Value.Marshal(b, m, deterministic)
}
func (m *UInt64Value) XXX_Merge(src proto.Message) {
xxx_messageInfo_UInt64Value.Merge(m, src)
}
func (m *UInt64Value) XXX_Size() int {
return xxx_messageInfo_UInt64Value.Size(m)
}
func (m *UInt64Value) XXX_DiscardUnknown() {
xxx_messageInfo_UInt64Value.DiscardUnknown(m)
}
var xxx_messageInfo_UInt64Value proto.InternalMessageInfo
func (m *UInt64Value) GetValue() uint64 {
if m != nil {
return m.Value
}
return 0
}
// Wrapper message for `int32`.
//
// The JSON representation for `Int32Value` is JSON number.
type Int32Value struct {
// The int32 value.
Value int32 `protobuf:"varint,1,opt,name=value,proto3" json:"value,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *Int32Value) Reset() { *m = Int32Value{} }
func (m *Int32Value) String() string { return proto.CompactTextString(m) }
func (*Int32Value) ProtoMessage() {}
func (*Int32Value) Descriptor() ([]byte, []int) {
return fileDescriptor_5377b62bda767935, []int{4}
}
func (*Int32Value) XXX_WellKnownType() string { return "Int32Value" }
func (m *Int32Value) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_Int32Value.Unmarshal(m, b)
}
func (m *Int32Value) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_Int32Value.Marshal(b, m, deterministic)
}
func (m *Int32Value) XXX_Merge(src proto.Message) {
xxx_messageInfo_Int32Value.Merge(m, src)
}
func (m *Int32Value) XXX_Size() int {
return xxx_messageInfo_Int32Value.Size(m)
}
func (m *Int32Value) XXX_DiscardUnknown() {
xxx_messageInfo_Int32Value.DiscardUnknown(m)
}
var xxx_messageInfo_Int32Value proto.InternalMessageInfo
func (m *Int32Value) GetValue() int32 {
if m != nil {
return m.Value
}
return 0
}
// Wrapper message for `uint32`.
//
// The JSON representation for `UInt32Value` is JSON number.
type UInt32Value struct {
// The uint32 value.
Value uint32 `protobuf:"varint,1,opt,name=value,proto3" json:"value,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *UInt32Value) Reset() { *m = UInt32Value{} }
func (m *UInt32Value) String() string { return proto.CompactTextString(m) }
func (*UInt32Value) ProtoMessage() {}
func (*UInt32Value) Descriptor() ([]byte, []int) {
return fileDescriptor_5377b62bda767935, []int{5}
}
func (*UInt32Value) XXX_WellKnownType() string { return "UInt32Value" }
func (m *UInt32Value) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_UInt32Value.Unmarshal(m, b)
}
func (m *UInt32Value) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_UInt32Value.Marshal(b, m, deterministic)
}
func (m *UInt32Value) XXX_Merge(src proto.Message) {
xxx_messageInfo_UInt32Value.Merge(m, src)
}
func (m *UInt32Value) XXX_Size() int {
return xxx_messageInfo_UInt32Value.Size(m)
}
func (m *UInt32Value) XXX_DiscardUnknown() {
xxx_messageInfo_UInt32Value.DiscardUnknown(m)
}
var xxx_messageInfo_UInt32Value proto.InternalMessageInfo
func (m *UInt32Value) GetValue() uint32 {
if m != nil {
return m.Value
}
return 0
}
// Wrapper message for `bool`.
//
// The JSON representation for `BoolValue` is JSON `true` and `false`.
type BoolValue struct {
// The bool value.
Value bool `protobuf:"varint,1,opt,name=value,proto3" json:"value,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *BoolValue) Reset() { *m = BoolValue{} }
func (m *BoolValue) String() string { return proto.CompactTextString(m) }
func (*BoolValue) ProtoMessage() {}
func (*BoolValue) Descriptor() ([]byte, []int) {
return fileDescriptor_5377b62bda767935, []int{6}
}
func (*BoolValue) XXX_WellKnownType() string { return "BoolValue" }
func (m *BoolValue) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_BoolValue.Unmarshal(m, b)
}
func (m *BoolValue) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_BoolValue.Marshal(b, m, deterministic)
}
func (m *BoolValue) XXX_Merge(src proto.Message) {
xxx_messageInfo_BoolValue.Merge(m, src)
}
func (m *BoolValue) XXX_Size() int {
return xxx_messageInfo_BoolValue.Size(m)
}
func (m *BoolValue) XXX_DiscardUnknown() {
xxx_messageInfo_BoolValue.DiscardUnknown(m)
}
var xxx_messageInfo_BoolValue proto.InternalMessageInfo
func (m *BoolValue) GetValue() bool {
if m != nil {
return m.Value
}
return false
}
// Wrapper message for `string`.
//
// The JSON representation for `StringValue` is JSON string.
type StringValue struct {
// The string value.
Value string `protobuf:"bytes,1,opt,name=value,proto3" json:"value,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *StringValue) Reset() { *m = StringValue{} }
func (m *StringValue) String() string { return proto.CompactTextString(m) }
func (*StringValue) ProtoMessage() {}
func (*StringValue) Descriptor() ([]byte, []int) {
return fileDescriptor_5377b62bda767935, []int{7}
}
func (*StringValue) XXX_WellKnownType() string { return "StringValue" }
func (m *StringValue) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_StringValue.Unmarshal(m, b)
}
func (m *StringValue) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_StringValue.Marshal(b, m, deterministic)
}
func (m *StringValue) XXX_Merge(src proto.Message) {
xxx_messageInfo_StringValue.Merge(m, src)
}
func (m *StringValue) XXX_Size() int {
return xxx_messageInfo_StringValue.Size(m)
}
func (m *StringValue) XXX_DiscardUnknown() {
xxx_messageInfo_StringValue.DiscardUnknown(m)
}
var xxx_messageInfo_StringValue proto.InternalMessageInfo
func (m *StringValue) GetValue() string {
if m != nil {
return m.Value
}
return ""
}
// Wrapper message for `bytes`.
//
// The JSON representation for `BytesValue` is JSON string.
type BytesValue struct {
// The bytes value.
Value []byte `protobuf:"bytes,1,opt,name=value,proto3" json:"value,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *BytesValue) Reset() { *m = BytesValue{} }
func (m *BytesValue) String() string { return proto.CompactTextString(m) }
func (*BytesValue) ProtoMessage() {}
func (*BytesValue) Descriptor() ([]byte, []int) {
return fileDescriptor_5377b62bda767935, []int{8}
}
func (*BytesValue) XXX_WellKnownType() string { return "BytesValue" }
func (m *BytesValue) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_BytesValue.Unmarshal(m, b)
}
func (m *BytesValue) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_BytesValue.Marshal(b, m, deterministic)
}
func (m *BytesValue) XXX_Merge(src proto.Message) {
xxx_messageInfo_BytesValue.Merge(m, src)
}
func (m *BytesValue) XXX_Size() int {
return xxx_messageInfo_BytesValue.Size(m)
}
func (m *BytesValue) XXX_DiscardUnknown() {
xxx_messageInfo_BytesValue.DiscardUnknown(m)
}
var xxx_messageInfo_BytesValue proto.InternalMessageInfo
func (m *BytesValue) GetValue() []byte {
if m != nil {
return m.Value
}
return nil
}
func init() {
proto.RegisterType((*DoubleValue)(nil), "google.protobuf.DoubleValue")
proto.RegisterType((*FloatValue)(nil), "google.protobuf.FloatValue")
proto.RegisterType((*Int64Value)(nil), "google.protobuf.Int64Value")
proto.RegisterType((*UInt64Value)(nil), "google.protobuf.UInt64Value")
proto.RegisterType((*Int32Value)(nil), "google.protobuf.Int32Value")
proto.RegisterType((*UInt32Value)(nil), "google.protobuf.UInt32Value")
proto.RegisterType((*BoolValue)(nil), "google.protobuf.BoolValue")
proto.RegisterType((*StringValue)(nil), "google.protobuf.StringValue")
proto.RegisterType((*BytesValue)(nil), "google.protobuf.BytesValue")
}
func init() {
proto.RegisterFile("google/protobuf/wrappers.proto", fileDescriptor_5377b62bda767935)
}
var fileDescriptor_5377b62bda767935 = []byte{
// 259 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x92, 0x4b, 0xcf, 0xcf, 0x4f,
0xcf, 0x49, 0xd5, 0x2f, 0x28, 0xca, 0x2f, 0xc9, 0x4f, 0x2a, 0x4d, 0xd3, 0x2f, 0x2f, 0x4a, 0x2c,
0x28, 0x48, 0x2d, 0x2a, 0xd6, 0x03, 0x8b, 0x08, 0xf1, 0x43, 0xe4, 0xf5, 0x60, 0xf2, 0x4a, 0xca,
0x5c, 0xdc, 0x2e, 0xf9, 0xa5, 0x49, 0x39, 0xa9, 0x61, 0x89, 0x39, 0xa5, 0xa9, 0x42, 0x22, 0x5c,
0xac, 0x65, 0x20, 0x86, 0x04, 0xa3, 0x02, 0xa3, 0x06, 0x63, 0x10, 0x84, 0xa3, 0xa4, 0xc4, 0xc5,
0xe5, 0x96, 0x93, 0x9f, 0x58, 0x82, 0x45, 0x0d, 0x13, 0x92, 0x1a, 0xcf, 0xbc, 0x12, 0x33, 0x13,
0x2c, 0x6a, 0x98, 0x61, 0x6a, 0x94, 0xb9, 0xb8, 0x43, 0x71, 0x29, 0x62, 0x41, 0x35, 0xc8, 0xd8,
0x08, 0x8b, 0x1a, 0x56, 0x34, 0x83, 0xb0, 0x2a, 0xe2, 0x85, 0x29, 0x52, 0xe4, 0xe2, 0x74, 0xca,
0xcf, 0xcf, 0xc1, 0xa2, 0x84, 0x03, 0xc9, 0x9c, 0xe0, 0x92, 0xa2, 0xcc, 0xbc, 0x74, 0x2c, 0x8a,
0x38, 0x91, 0x1c, 0xe4, 0x54, 0x59, 0x92, 0x5a, 0x8c, 0x45, 0x0d, 0x0f, 0x54, 0x8d, 0x53, 0x0d,
0x97, 0x70, 0x72, 0x7e, 0xae, 0x1e, 0x5a, 0xe8, 0x3a, 0xf1, 0x86, 0x43, 0x83, 0x3f, 0x00, 0x24,
0x12, 0xc0, 0x18, 0xa5, 0x95, 0x9e, 0x59, 0x92, 0x51, 0x9a, 0xa4, 0x97, 0x9c, 0x9f, 0xab, 0x9f,
0x9e, 0x9f, 0x93, 0x98, 0x97, 0x8e, 0x88, 0xaa, 0x82, 0x92, 0xca, 0x82, 0xd4, 0x62, 0x78, 0x8c,
0xfd, 0x60, 0x64, 0x5c, 0xc4, 0xc4, 0xec, 0x1e, 0xe0, 0xb4, 0x8a, 0x49, 0xce, 0x1d, 0x62, 0x6e,
0x00, 0x54, 0xa9, 0x5e, 0x78, 0x6a, 0x4e, 0x8e, 0x77, 0x5e, 0x7e, 0x79, 0x5e, 0x08, 0x48, 0x4b,
0x12, 0x1b, 0xd8, 0x0c, 0x63, 0x40, 0x00, 0x00, 0x00, 0xff, 0xff, 0x19, 0x6c, 0xb9, 0xb8, 0xfe,
0x01, 0x00, 0x00,
type x struct{}
out := protoimpl.TypeBuilder{
File: protoimpl.DescBuilder{
GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
RawDescriptor: file_github_com_golang_protobuf_ptypes_wrappers_wrappers_proto_rawDesc,
NumEnums: 0,
NumMessages: 0,
NumExtensions: 0,
NumServices: 0,
},
GoTypes: file_github_com_golang_protobuf_ptypes_wrappers_wrappers_proto_goTypes,
DependencyIndexes: file_github_com_golang_protobuf_ptypes_wrappers_wrappers_proto_depIdxs,
}.Build()
File_github_com_golang_protobuf_ptypes_wrappers_wrappers_proto = out.File
file_github_com_golang_protobuf_ptypes_wrappers_wrappers_proto_rawDesc = nil
file_github_com_golang_protobuf_ptypes_wrappers_wrappers_proto_goTypes = nil
file_github_com_golang_protobuf_ptypes_wrappers_wrappers_proto_depIdxs = nil
}

123
vendor/github.com/golang/protobuf/ptypes/wrappers/wrappers.proto generated vendored
View file

@ -1,123 +0,0 @@
// Protocol Buffers - Google's data interchange format
// Copyright 2008 Google Inc. All rights reserved.
// https://developers.google.com/protocol-buffers/
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
// * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
// * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following disclaimer
// in the documentation and/or other materials provided with the
// distribution.
// * Neither the name of Google Inc. nor the names of its
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
// Wrappers for primitive (non-message) types. These types are useful
// for embedding primitives in the `google.protobuf.Any` type and for places
// where we need to distinguish between the absence of a primitive
// typed field and its default value.
//
// These wrappers have no meaningful use within repeated fields as they lack
// the ability to detect presence on individual elements.
// These wrappers have no meaningful use within a map or a oneof since
// individual entries of a map or fields of a oneof can already detect presence.
syntax = "proto3";
package google.protobuf;
option csharp_namespace = "Google.Protobuf.WellKnownTypes";
option cc_enable_arenas = true;
option go_package = "github.com/golang/protobuf/ptypes/wrappers";
option java_package = "com.google.protobuf";
option java_outer_classname = "WrappersProto";
option java_multiple_files = true;
option objc_class_prefix = "GPB";
// Wrapper message for `double`.
//
// The JSON representation for `DoubleValue` is JSON number.
message DoubleValue {
// The double value.
double value = 1;
}
// Wrapper message for `float`.
//
// The JSON representation for `FloatValue` is JSON number.
message FloatValue {
// The float value.
float value = 1;
}
// Wrapper message for `int64`.
//
// The JSON representation for `Int64Value` is JSON string.
message Int64Value {
// The int64 value.
int64 value = 1;
}
// Wrapper message for `uint64`.
//
// The JSON representation for `UInt64Value` is JSON string.
message UInt64Value {
// The uint64 value.
uint64 value = 1;
}
// Wrapper message for `int32`.
//
// The JSON representation for `Int32Value` is JSON number.
message Int32Value {
// The int32 value.
int32 value = 1;
}
// Wrapper message for `uint32`.
//
// The JSON representation for `UInt32Value` is JSON number.
message UInt32Value {
// The uint32 value.
uint32 value = 1;
}
// Wrapper message for `bool`.
//
// The JSON representation for `BoolValue` is JSON `true` and `false`.
message BoolValue {
// The bool value.
bool value = 1;
}
// Wrapper message for `string`.
//
// The JSON representation for `StringValue` is JSON string.
message StringValue {
// The string value.
string value = 1;
}
// Wrapper message for `bytes`.
//
// The JSON representation for `BytesValue` is JSON string.
message BytesValue {
// The bytes value.
bytes value = 1;
}

87
vendor/github.com/yandex-cloud/go-genproto/yandex/cloud/access/access.pb.go generated vendored
View file

@ -57,16 +57,18 @@ type Subject struct {
// It can contain one of the following values:
// * `allAuthenticatedUsers`: A special system identifier that represents anyone
// who is authenticated. It can be used only if the [type] is `system`.
//
// * `allUsers`: A special system identifier that represents anyone. No authentication is required.
// For example, you don't need to specify the IAM token in an API query.
// * `<cloud generated id>`: An identifier that represents a user account.
// It can be used only if the [type] is `userAccount` or `serviceAccount`.
Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
// Type of the subject.
//
// It can contain one of the following values:
// * `system`: System group. This type represents several accounts with a common system identifier.
// * `userAccount`: An user account (for example, "alice.the.girl@yandex.ru"). This type represents the [yandex.cloud.iam.v1.UserAccount] resource.
// * `userAccount`: An account on Yandex or [Yandex.Connect](https://connect.yandex.com), added to Yandex.Cloud.
// * `serviceAccount`: A service account. This type represents the [yandex.cloud.iam.v1.ServiceAccount] resource.
// * `federatedUser`: A federated account. This type represents a user from an identity federation, like Active Directory.
// * `system`: System group. This type represents several accounts with a common system identifier.
//
// For more information, see [Subject to which the role is assigned](/docs/iam/concepts/access-control/#subject).
Type string `protobuf:"bytes,2,opt,name=type,proto3" json:"type,omitempty"`
@ -527,44 +529,47 @@ func init() {
proto.RegisterType((*AccessBindingDelta)(nil), "yandex.cloud.access.AccessBindingDelta")
}
func init() { proto.RegisterFile("yandex/cloud/access/access.proto", fileDescriptor_f72fa1116199e82e) }
func init() {
proto.RegisterFile("yandex/cloud/access/access.proto", fileDescriptor_f72fa1116199e82e)
}
var fileDescriptor_f72fa1116199e82e = []byte{
// 573 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x94, 0xdf, 0x6e, 0xd3, 0x30,
0x14, 0xc6, 0x49, 0x5b, 0xda, 0xf5, 0x54, 0xed, 0x2a, 0x57, 0x48, 0xd9, 0x18, 0xa2, 0x8b, 0x34,
0x56, 0x21, 0x2d, 0xfd, 0x83, 0x10, 0x17, 0x74, 0x40, 0xd3, 0x76, 0x28, 0x82, 0xb5, 0x5b, 0xb2,
0x71, 0xc1, 0x4d, 0xe4, 0x26, 0x56, 0x09, 0x94, 0x24, 0xd4, 0x2e, 0xda, 0xf6, 0x08, 0xbb, 0x43,
0x82, 0x67, 0xe0, 0x8a, 0xe7, 0xd8, 0x1e, 0x85, 0x67, 0xe0, 0x0a, 0xc5, 0x4e, 0x51, 0x43, 0x23,
0xad, 0xd2, 0xae, 0x1c, 0xe5, 0x3b, 0xe7, 0x3b, 0xbf, 0xcf, 0x96, 0x0d, 0xd5, 0x73, 0xec, 0x39,
0xe4, 0xac, 0x6e, 0x4f, 0xfc, 0x99, 0x53, 0xc7, 0xb6, 0x4d, 0x28, 0x8d, 0x16, 0x35, 0x98, 0xfa,
0xcc, 0x47, 0x15, 0x51, 0xa1, 0xf2, 0x0a, 0x55, 0x48, 0x9b, 0x0f, 0x62, 0x6d, 0x5f, 0xf1, 0xc4,
0x75, 0x30, 0x73, 0x7d, 0x4f, 0xf4, 0x28, 0xcf, 0x20, 0x67, 0xce, 0x46, 0x1f, 0x89, 0xcd, 0x90,
0x0c, 0x29, 0xd7, 0x91, 0xa5, 0xaa, 0x54, 0xcb, 0x6b, 0x6b, 0x97, 0xd7, 0xcd, 0x4c, 0x7b, 0xff,
0x69, 0xc3, 0x48, 0xb9, 0x0e, 0x42, 0x90, 0x61, 0xe7, 0x01, 0x91, 0x53, 0xa1, 0x66, 0xf0, 0x6f,
0x25, 0x80, 0x62, 0x87, 0x4f, 0xd0, 0x5c, 0xcf, 0x71, 0xbd, 0x31, 0xda, 0x86, 0xdc, 0xd4, 0x9f,
0x10, 0x2b, 0xc1, 0x23, 0x1b, 0x0a, 0xba, 0x83, 0xda, 0x90, 0xa3, 0x62, 0x18, 0xb7, 0x2a, 0xb4,
0xb6, 0xd4, 0x04, 0x64, 0x35, 0x02, 0xd2, 0x32, 0xbf, 0xaf, 0x9a, 0x92, 0x31, 0x6f, 0x51, 0x7e,
0x48, 0xb0, 0xf1, 0xd6, 0xa5, 0x2c, 0x36, 0x96, 0x1a, 0xe4, 0xcb, 0x8c, 0x50, 0x86, 0x76, 0xa0,
0x30, 0x25, 0xd4, 0x9f, 0x4d, 0xed, 0x05, 0x04, 0xe1, 0x00, 0x73, 0x41, 0x77, 0xd0, 0x2e, 0xe4,
0x03, 0x3c, 0x26, 0x16, 0x75, 0x2f, 0x44, 0x9e, 0xb4, 0x06, 0x7f, 0xae, 0x9a, 0xd9, 0xf6, 0x7e,
0xb3, 0xd1, 0x68, 0x18, 0x6b, 0xa1, 0x68, 0xba, 0x17, 0x04, 0xd5, 0x00, 0x78, 0x21, 0xf3, 0x3f,
0x11, 0x4f, 0x4e, 0x73, 0xbb, 0xfc, 0xe5, 0x75, 0xf3, 0x2e, 0xaf, 0x34, 0xb8, 0xcb, 0x49, 0xa8,
0x29, 0xdf, 0x24, 0xd8, 0x4c, 0xe2, 0xa2, 0x81, 0xef, 0x51, 0x82, 0xde, 0xc0, 0xba, 0xc8, 0x65,
0x8d, 0x22, 0x49, 0x96, 0xaa, 0xe9, 0x5a, 0xa1, 0xa5, 0x24, 0x86, 0x8f, 0xb9, 0x18, 0x25, 0x1c,
0x33, 0x45, 0x8f, 0x60, 0xdd, 0x23, 0x67, 0xcc, 0x5a, 0x40, 0x13, 0x87, 0x52, 0x0c, 0x7f, 0x1f,
0xfd, 0x63, 0xfa, 0x2e, 0x81, 0x6c, 0x92, 0xdb, 0x6d, 0xd5, 0xf1, 0x32, 0x78, 0x6a, 0x55, 0xf0,
0xc8, 0xee, 0x3f, 0x7c, 0xa5, 0x0d, 0x1b, 0x4b, 0x54, 0x87, 0x84, 0x61, 0x07, 0x33, 0x8c, 0x1e,
0x26, 0x60, 0x2d, 0x02, 0x29, 0x3f, 0x25, 0xb8, 0x7f, 0x1a, 0x38, 0x98, 0x91, 0x5b, 0xe5, 0xc2,
0x70, 0x2f, 0x9e, 0xcb, 0x72, 0xc8, 0x84, 0xe1, 0x79, 0xba, 0xdd, 0x9b, 0xd3, 0xf5, 0xc2, 0xfa,
0xc8, 0xb9, 0x82, 0x97, 0x14, 0xaa, 0xbc, 0x84, 0xad, 0x24, 0xd0, 0xd5, 0xa3, 0xfe, 0x92, 0x00,
0x2d, 0x8f, 0x44, 0x07, 0x90, 0xc5, 0x76, 0x78, 0x7b, 0x79, 0x4b, 0xa9, 0x55, 0xbb, 0x99, 0xb5,
0xc3, 0xeb, 0x23, 0xd8, 0xa8, 0x1b, 0x0d, 0xa1, 0x14, 0xdf, 0x82, 0xe8, 0x3e, 0xae, 0x7e, 0xb2,
0xc5, 0x58, 0xec, 0xc7, 0xc7, 0x50, 0x49, 0x98, 0x8a, 0x76, 0x60, 0xbb, 0xd3, 0xed, 0xf6, 0x4d,
0xd3, 0xd2, 0xf4, 0x41, 0x4f, 0x1f, 0xbc, 0xb6, 0x3a, 0xdd, 0x13, 0x7d, 0x38, 0xb0, 0x4e, 0x07,
0xe6, 0x51, 0xbf, 0xab, 0x1f, 0xe8, 0xfd, 0x5e, 0xf9, 0x0e, 0xca, 0x41, 0xba, 0xd3, 0xeb, 0x95,
0x25, 0x04, 0x90, 0x35, 0xfa, 0x87, 0xc3, 0x77, 0xfd, 0x72, 0x4a, 0x7b, 0xf5, 0xfe, 0xc5, 0xd8,
0x65, 0x1f, 0x66, 0x23, 0xd5, 0xf6, 0x3f, 0xd7, 0x05, 0xd7, 0x9e, 0x78, 0xc5, 0xc6, 0xfe, 0xde,
0x98, 0x78, 0xfc, 0x01, 0xab, 0x27, 0xbc, 0x8a, 0xcf, 0xc5, 0x32, 0xca, 0xf2, 0x8a, 0x27, 0x7f,
0x03, 0x00, 0x00, 0xff, 0xff, 0x95, 0xc1, 0x18, 0x94, 0x3a, 0x05, 0x00, 0x00,
// 581 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x94, 0x5f, 0x6f, 0xd2, 0x5e,
0x1c, 0xc6, 0x7f, 0x05, 0x7e, 0x30, 0xbe, 0x04, 0x46, 0x0e, 0x31, 0x76, 0x73, 0x46, 0xd6, 0x64,
0x8e, 0x98, 0xac, 0xfc, 0x31, 0xc6, 0x0b, 0x99, 0x86, 0x02, 0x33, 0x8d, 0x0e, 0xb6, 0x76, 0x33,
0xd1, 0x9b, 0xe6, 0xd0, 0x9e, 0x60, 0x15, 0xdb, 0xca, 0x39, 0x98, 0x6d, 0x2f, 0x61, 0x77, 0x26,
0xfa, 0x1a, 0xbc, 0xf2, 0x75, 0x6c, 0x2f, 0xc5, 0xd7, 0xe0, 0x95, 0xe9, 0x39, 0xc5, 0x50, 0x69,
0x32, 0x92, 0x5d, 0x95, 0xf0, 0x3c, 0xdf, 0xe7, 0xfb, 0x79, 0xda, 0x9c, 0x03, 0xd5, 0x73, 0xec,
0x39, 0xe4, 0xac, 0x6e, 0x4f, 0xfc, 0x99, 0x53, 0xc7, 0xb6, 0x4d, 0x28, 0x8d, 0x1e, 0x6a, 0x30,
0xf5, 0x99, 0x8f, 0x2a, 0xc2, 0xa1, 0x72, 0x87, 0x2a, 0xa4, 0xcd, 0xfb, 0xb1, 0xb1, 0x2f, 0x78,
0xe2, 0x3a, 0x98, 0xb9, 0xbe, 0x27, 0x66, 0x94, 0xa7, 0x90, 0x33, 0x67, 0xa3, 0x0f, 0xc4, 0x66,
0x48, 0x86, 0x94, 0xeb, 0xc8, 0x52, 0x55, 0xaa, 0xe5, 0xb5, 0xb5, 0xcb, 0xeb, 0x66, 0xa6, 0xbd,
0xff, 0xa4, 0x61, 0xa4, 0x5c, 0x07, 0x21, 0xc8, 0xb0, 0xf3, 0x80, 0xc8, 0xa9, 0x50, 0x33, 0xf8,
0x6f, 0x25, 0x80, 0x62, 0x87, 0x6f, 0xd0, 0x5c, 0xcf, 0x71, 0xbd, 0x31, 0xda, 0x86, 0xdc, 0xd4,
0x9f, 0x10, 0x2b, 0x21, 0x23, 0x1b, 0x0a, 0xba, 0x83, 0xda, 0x90, 0xa3, 0x62, 0x19, 0x8f, 0x2a,
0xb4, 0xb6, 0xd4, 0x04, 0x64, 0x35, 0x02, 0xd2, 0x32, 0xbf, 0xae, 0x9a, 0x92, 0x31, 0x1f, 0x51,
0xbe, 0x4b, 0xb0, 0xf1, 0xda, 0xa5, 0x2c, 0xb6, 0x96, 0x1a, 0xe4, 0xf3, 0x8c, 0x50, 0x86, 0x76,
0xa0, 0x30, 0x25, 0xd4, 0x9f, 0x4d, 0xed, 0x05, 0x04, 0x91, 0x00, 0x73, 0x41, 0x77, 0xd0, 0x2e,
0xe4, 0x03, 0x3c, 0x26, 0x16, 0x75, 0x2f, 0x44, 0x9f, 0xb4, 0x06, 0xbf, 0xaf, 0x9a, 0xd9, 0xf6,
0x7e, 0xb3, 0xd1, 0x68, 0x18, 0x6b, 0xa1, 0x68, 0xba, 0x17, 0x04, 0xd5, 0x00, 0xb8, 0x91, 0xf9,
0x1f, 0x89, 0x27, 0xa7, 0x79, 0x5c, 0xfe, 0xf2, 0xba, 0xf9, 0x3f, 0x77, 0x1a, 0x3c, 0xe5, 0x24,
0xd4, 0x94, 0xaf, 0x12, 0x6c, 0x26, 0x71, 0xd1, 0xc0, 0xf7, 0x28, 0x41, 0xaf, 0x60, 0x5d, 0xf4,
0xb2, 0x46, 0x91, 0x24, 0x4b, 0xd5, 0x74, 0xad, 0xd0, 0x52, 0x12, 0xcb, 0xc7, 0x52, 0x8c, 0x12,
0x8e, 0x85, 0xa2, 0x87, 0xb0, 0xee, 0x91, 0x33, 0x66, 0x2d, 0xa0, 0x89, 0x8f, 0x52, 0x0c, 0xff,
0x3e, 0xfa, 0xcb, 0xf4, 0x4d, 0x02, 0xd9, 0x24, 0xb7, 0x7b, 0x55, 0xc7, 0xcb, 0xe0, 0xa9, 0x55,
0xc1, 0xa3, 0xb8, 0x7f, 0xf0, 0x95, 0x36, 0x6c, 0x2c, 0x51, 0x1d, 0x12, 0x86, 0x1d, 0xcc, 0x30,
0x7a, 0x90, 0x80, 0xb5, 0x08, 0xa4, 0xfc, 0x90, 0xe0, 0xde, 0x69, 0xe0, 0x60, 0x46, 0x6e, 0xd5,
0x0b, 0xc3, 0x9d, 0x78, 0x2f, 0xcb, 0x21, 0x13, 0x86, 0xe7, 0xed, 0x76, 0x6f, 0x6e, 0xd7, 0x0b,
0xfd, 0x51, 0x72, 0x05, 0x2f, 0x29, 0x54, 0x79, 0x01, 0x5b, 0x49, 0xa0, 0xab, 0x57, 0xfd, 0x29,
0x01, 0x5a, 0x5e, 0x89, 0x0e, 0x20, 0x8b, 0xed, 0xf0, 0xf4, 0xf2, 0x91, 0x52, 0xab, 0x76, 0x33,
0x6b, 0x87, 0xfb, 0x23, 0xd8, 0x68, 0x1a, 0x0d, 0xa1, 0x14, 0x7f, 0x05, 0xd1, 0x79, 0x5c, 0xfd,
0xcb, 0x16, 0x63, 0xb5, 0x1f, 0x1d, 0x43, 0x25, 0x61, 0x2b, 0xda, 0x81, 0xed, 0x4e, 0xb7, 0xdb,
0x37, 0x4d, 0x4b, 0xd3, 0x07, 0x3d, 0x7d, 0xf0, 0xd2, 0xea, 0x74, 0x4f, 0xf4, 0xe1, 0xc0, 0x3a,
0x1d, 0x98, 0x47, 0xfd, 0xae, 0x7e, 0xa0, 0xf7, 0x7b, 0xe5, 0xff, 0x50, 0x0e, 0xd2, 0x9d, 0x5e,
0xaf, 0x2c, 0x21, 0x80, 0xac, 0xd1, 0x3f, 0x1c, 0xbe, 0xe9, 0x97, 0x53, 0xda, 0x5b, 0xb8, 0x1b,
0x87, 0x09, 0xdc, 0x08, 0xe8, 0xdd, 0xf3, 0xb1, 0xcb, 0xde, 0xcf, 0x46, 0xaa, 0xed, 0x7f, 0xaa,
0x0b, 0xcf, 0x9e, 0xb8, 0xde, 0xc6, 0xfe, 0xde, 0x98, 0x78, 0xfc, 0x66, 0xab, 0x27, 0x5c, 0x97,
0xcf, 0xc4, 0x63, 0x94, 0xe5, 0x8e, 0xc7, 0x7f, 0x02, 0x00, 0x00, 0xff, 0xff, 0x03, 0xb2, 0xd6,
0xf5, 0x53, 0x05, 0x00, 0x00,
}

71
vendor/github.com/yandex-cloud/go-genproto/yandex/cloud/access/access.pbext.go generated vendored Normal file
View file

@ -0,0 +1,71 @@
// Code generated by protoc-gen-goext. DO NOT EDIT.
package access
func (m *Subject) SetId(v string) {
m.Id = v
}
func (m *Subject) SetType(v string) {
m.Type = v
}
func (m *AccessBinding) SetRoleId(v string) {
m.RoleId = v
}
func (m *AccessBinding) SetSubject(v *Subject) {
m.Subject = v
}
func (m *ListAccessBindingsRequest) SetResourceId(v string) {
m.ResourceId = v
}
func (m *ListAccessBindingsRequest) SetPageSize(v int64) {
m.PageSize = v
}
func (m *ListAccessBindingsRequest) SetPageToken(v string) {
m.PageToken = v
}
func (m *ListAccessBindingsResponse) SetAccessBindings(v []*AccessBinding) {
m.AccessBindings = v
}
func (m *ListAccessBindingsResponse) SetNextPageToken(v string) {
m.NextPageToken = v
}
func (m *SetAccessBindingsRequest) SetResourceId(v string) {
m.ResourceId = v
}
func (m *SetAccessBindingsRequest) SetAccessBindings(v []*AccessBinding) {
m.AccessBindings = v
}
func (m *SetAccessBindingsMetadata) SetResourceId(v string) {
m.ResourceId = v
}
func (m *UpdateAccessBindingsRequest) SetResourceId(v string) {
m.ResourceId = v
}
func (m *UpdateAccessBindingsRequest) SetAccessBindingDeltas(v []*AccessBindingDelta) {
m.AccessBindingDeltas = v
}
func (m *UpdateAccessBindingsMetadata) SetResourceId(v string) {
m.ResourceId = v
}
func (m *AccessBindingDelta) SetAction(v AccessBindingAction) {
m.Action = v
}
func (m *AccessBindingDelta) SetAccessBinding(v *AccessBinding) {
m.AccessBinding = v
}

962
vendor/github.com/yandex-cloud/go-genproto/yandex/cloud/ai/stt/v2/stt_service.pb.go generated vendored Normal file
View file

@ -0,0 +1,962 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
// source: yandex/cloud/ai/stt/v2/stt_service.proto
package stt
import (
context "context"
fmt "fmt"
proto "github.com/golang/protobuf/proto"
duration "github.com/golang/protobuf/ptypes/duration"
_ "github.com/yandex-cloud/go-genproto/yandex/cloud/api"
operation "github.com/yandex-cloud/go-genproto/yandex/cloud/operation"
_ "google.golang.org/genproto/googleapis/api/annotations"
grpc "google.golang.org/grpc"
codes "google.golang.org/grpc/codes"
status "google.golang.org/grpc/status"
math "math"
)
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf
// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.ProtoPackageIsVersion3 // please upgrade the proto package
type RecognitionSpec_AudioEncoding int32
const (
RecognitionSpec_AUDIO_ENCODING_UNSPECIFIED RecognitionSpec_AudioEncoding = 0
// 16-bit signed little-endian (Linear PCM)
RecognitionSpec_LINEAR16_PCM RecognitionSpec_AudioEncoding = 1
RecognitionSpec_OGG_OPUS RecognitionSpec_AudioEncoding = 2
)
var RecognitionSpec_AudioEncoding_name = map[int32]string{
0: "AUDIO_ENCODING_UNSPECIFIED",
1: "LINEAR16_PCM",
2: "OGG_OPUS",
}
var RecognitionSpec_AudioEncoding_value = map[string]int32{
"AUDIO_ENCODING_UNSPECIFIED": 0,
"LINEAR16_PCM": 1,
"OGG_OPUS": 2,
}
func (x RecognitionSpec_AudioEncoding) String() string {
return proto.EnumName(RecognitionSpec_AudioEncoding_name, int32(x))
}
func (RecognitionSpec_AudioEncoding) EnumDescriptor() ([]byte, []int) {
return fileDescriptor_44de6807abd10de5, []int{6, 0}
}
type LongRunningRecognitionRequest struct {
Config *RecognitionConfig `protobuf:"bytes,1,opt,name=config,proto3" json:"config,omitempty"`
Audio *RecognitionAudio `protobuf:"bytes,2,opt,name=audio,proto3" json:"audio,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *LongRunningRecognitionRequest) Reset() { *m = LongRunningRecognitionRequest{} }
func (m *LongRunningRecognitionRequest) String() string { return proto.CompactTextString(m) }
func (*LongRunningRecognitionRequest) ProtoMessage() {}
func (*LongRunningRecognitionRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_44de6807abd10de5, []int{0}
}
func (m *LongRunningRecognitionRequest) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_LongRunningRecognitionRequest.Unmarshal(m, b)
}
func (m *LongRunningRecognitionRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_LongRunningRecognitionRequest.Marshal(b, m, deterministic)
}
func (m *LongRunningRecognitionRequest) XXX_Merge(src proto.Message) {
xxx_messageInfo_LongRunningRecognitionRequest.Merge(m, src)
}
func (m *LongRunningRecognitionRequest) XXX_Size() int {
return xxx_messageInfo_LongRunningRecognitionRequest.Size(m)
}
func (m *LongRunningRecognitionRequest) XXX_DiscardUnknown() {
xxx_messageInfo_LongRunningRecognitionRequest.DiscardUnknown(m)
}
var xxx_messageInfo_LongRunningRecognitionRequest proto.InternalMessageInfo
func (m *LongRunningRecognitionRequest) GetConfig() *RecognitionConfig {
if m != nil {
return m.Config
}
return nil
}
func (m *LongRunningRecognitionRequest) GetAudio() *RecognitionAudio {
if m != nil {
return m.Audio
}
return nil
}
type LongRunningRecognitionResponse struct {
Chunks []*SpeechRecognitionResult `protobuf:"bytes,1,rep,name=chunks,proto3" json:"chunks,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *LongRunningRecognitionResponse) Reset() { *m = LongRunningRecognitionResponse{} }
func (m *LongRunningRecognitionResponse) String() string { return proto.CompactTextString(m) }
func (*LongRunningRecognitionResponse) ProtoMessage() {}
func (*LongRunningRecognitionResponse) Descriptor() ([]byte, []int) {
return fileDescriptor_44de6807abd10de5, []int{1}
}
func (m *LongRunningRecognitionResponse) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_LongRunningRecognitionResponse.Unmarshal(m, b)
}
func (m *LongRunningRecognitionResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_LongRunningRecognitionResponse.Marshal(b, m, deterministic)
}
func (m *LongRunningRecognitionResponse) XXX_Merge(src proto.Message) {
xxx_messageInfo_LongRunningRecognitionResponse.Merge(m, src)
}
func (m *LongRunningRecognitionResponse) XXX_Size() int {
return xxx_messageInfo_LongRunningRecognitionResponse.Size(m)
}
func (m *LongRunningRecognitionResponse) XXX_DiscardUnknown() {
xxx_messageInfo_LongRunningRecognitionResponse.DiscardUnknown(m)
}
var xxx_messageInfo_LongRunningRecognitionResponse proto.InternalMessageInfo
func (m *LongRunningRecognitionResponse) GetChunks() []*SpeechRecognitionResult {
if m != nil {
return m.Chunks
}
return nil
}
type StreamingRecognitionRequest struct {
// Types that are valid to be assigned to StreamingRequest:
// *StreamingRecognitionRequest_Config
// *StreamingRecognitionRequest_AudioContent
StreamingRequest isStreamingRecognitionRequest_StreamingRequest `protobuf_oneof:"streaming_request"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *StreamingRecognitionRequest) Reset() { *m = StreamingRecognitionRequest{} }
func (m *StreamingRecognitionRequest) String() string { return proto.CompactTextString(m) }
func (*StreamingRecognitionRequest) ProtoMessage() {}
func (*StreamingRecognitionRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_44de6807abd10de5, []int{2}
}
func (m *StreamingRecognitionRequest) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_StreamingRecognitionRequest.Unmarshal(m, b)
}
func (m *StreamingRecognitionRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_StreamingRecognitionRequest.Marshal(b, m, deterministic)
}
func (m *StreamingRecognitionRequest) XXX_Merge(src proto.Message) {
xxx_messageInfo_StreamingRecognitionRequest.Merge(m, src)
}
func (m *StreamingRecognitionRequest) XXX_Size() int {
return xxx_messageInfo_StreamingRecognitionRequest.Size(m)
}
func (m *StreamingRecognitionRequest) XXX_DiscardUnknown() {
xxx_messageInfo_StreamingRecognitionRequest.DiscardUnknown(m)
}
var xxx_messageInfo_StreamingRecognitionRequest proto.InternalMessageInfo
type isStreamingRecognitionRequest_StreamingRequest interface {
isStreamingRecognitionRequest_StreamingRequest()
}
type StreamingRecognitionRequest_Config struct {
Config *RecognitionConfig `protobuf:"bytes,1,opt,name=config,proto3,oneof"`
}
type StreamingRecognitionRequest_AudioContent struct {
AudioContent []byte `protobuf:"bytes,2,opt,name=audio_content,json=audioContent,proto3,oneof"`
}
func (*StreamingRecognitionRequest_Config) isStreamingRecognitionRequest_StreamingRequest() {}
func (*StreamingRecognitionRequest_AudioContent) isStreamingRecognitionRequest_StreamingRequest() {}
func (m *StreamingRecognitionRequest) GetStreamingRequest() isStreamingRecognitionRequest_StreamingRequest {
if m != nil {
return m.StreamingRequest
}
return nil
}
func (m *StreamingRecognitionRequest) GetConfig() *RecognitionConfig {
if x, ok := m.GetStreamingRequest().(*StreamingRecognitionRequest_Config); ok {
return x.Config
}
return nil
}
func (m *StreamingRecognitionRequest) GetAudioContent() []byte {
if x, ok := m.GetStreamingRequest().(*StreamingRecognitionRequest_AudioContent); ok {
return x.AudioContent
}
return nil
}
// XXX_OneofWrappers is for the internal use of the proto package.
func (*StreamingRecognitionRequest) XXX_OneofWrappers() []interface{} {
return []interface{}{
(*StreamingRecognitionRequest_Config)(nil),
(*StreamingRecognitionRequest_AudioContent)(nil),
}
}
type StreamingRecognitionResponse struct {
Chunks []*SpeechRecognitionChunk `protobuf:"bytes,1,rep,name=chunks,proto3" json:"chunks,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *StreamingRecognitionResponse) Reset() { *m = StreamingRecognitionResponse{} }
func (m *StreamingRecognitionResponse) String() string { return proto.CompactTextString(m) }
func (*StreamingRecognitionResponse) ProtoMessage() {}
func (*StreamingRecognitionResponse) Descriptor() ([]byte, []int) {
return fileDescriptor_44de6807abd10de5, []int{3}
}
func (m *StreamingRecognitionResponse) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_StreamingRecognitionResponse.Unmarshal(m, b)
}
func (m *StreamingRecognitionResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_StreamingRecognitionResponse.Marshal(b, m, deterministic)
}
func (m *StreamingRecognitionResponse) XXX_Merge(src proto.Message) {
xxx_messageInfo_StreamingRecognitionResponse.Merge(m, src)
}
func (m *StreamingRecognitionResponse) XXX_Size() int {
return xxx_messageInfo_StreamingRecognitionResponse.Size(m)
}
func (m *StreamingRecognitionResponse) XXX_DiscardUnknown() {
xxx_messageInfo_StreamingRecognitionResponse.DiscardUnknown(m)
}
var xxx_messageInfo_StreamingRecognitionResponse proto.InternalMessageInfo
func (m *StreamingRecognitionResponse) GetChunks() []*SpeechRecognitionChunk {
if m != nil {
return m.Chunks
}
return nil
}
type RecognitionAudio struct {
// Types that are valid to be assigned to AudioSource:
// *RecognitionAudio_Content
// *RecognitionAudio_Uri
AudioSource isRecognitionAudio_AudioSource `protobuf_oneof:"audio_source"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *RecognitionAudio) Reset() { *m = RecognitionAudio{} }
func (m *RecognitionAudio) String() string { return proto.CompactTextString(m) }
func (*RecognitionAudio) ProtoMessage() {}
func (*RecognitionAudio) Descriptor() ([]byte, []int) {
return fileDescriptor_44de6807abd10de5, []int{4}
}
func (m *RecognitionAudio) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_RecognitionAudio.Unmarshal(m, b)
}
func (m *RecognitionAudio) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_RecognitionAudio.Marshal(b, m, deterministic)
}
func (m *RecognitionAudio) XXX_Merge(src proto.Message) {
xxx_messageInfo_RecognitionAudio.Merge(m, src)
}
func (m *RecognitionAudio) XXX_Size() int {
return xxx_messageInfo_RecognitionAudio.Size(m)
}
func (m *RecognitionAudio) XXX_DiscardUnknown() {
xxx_messageInfo_RecognitionAudio.DiscardUnknown(m)
}
var xxx_messageInfo_RecognitionAudio proto.InternalMessageInfo
type isRecognitionAudio_AudioSource interface {
isRecognitionAudio_AudioSource()
}
type RecognitionAudio_Content struct {
Content []byte `protobuf:"bytes,1,opt,name=content,proto3,oneof"`
}
type RecognitionAudio_Uri struct {
Uri string `protobuf:"bytes,2,opt,name=uri,proto3,oneof"`
}
func (*RecognitionAudio_Content) isRecognitionAudio_AudioSource() {}
func (*RecognitionAudio_Uri) isRecognitionAudio_AudioSource() {}
func (m *RecognitionAudio) GetAudioSource() isRecognitionAudio_AudioSource {
if m != nil {
return m.AudioSource
}
return nil
}
func (m *RecognitionAudio) GetContent() []byte {
if x, ok := m.GetAudioSource().(*RecognitionAudio_Content); ok {
return x.Content
}
return nil
}
func (m *RecognitionAudio) GetUri() string {
if x, ok := m.GetAudioSource().(*RecognitionAudio_Uri); ok {
return x.Uri
}
return ""
}
// XXX_OneofWrappers is for the internal use of the proto package.
func (*RecognitionAudio) XXX_OneofWrappers() []interface{} {
return []interface{}{
(*RecognitionAudio_Content)(nil),
(*RecognitionAudio_Uri)(nil),
}
}
type RecognitionConfig struct {
Specification *RecognitionSpec `protobuf:"bytes,1,opt,name=specification,proto3" json:"specification,omitempty"`
FolderId string `protobuf:"bytes,2,opt,name=folder_id,json=folderId,proto3" json:"folder_id,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *RecognitionConfig) Reset() { *m = RecognitionConfig{} }
func (m *RecognitionConfig) String() string { return proto.CompactTextString(m) }
func (*RecognitionConfig) ProtoMessage() {}
func (*RecognitionConfig) Descriptor() ([]byte, []int) {
return fileDescriptor_44de6807abd10de5, []int{5}
}
func (m *RecognitionConfig) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_RecognitionConfig.Unmarshal(m, b)
}
func (m *RecognitionConfig) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_RecognitionConfig.Marshal(b, m, deterministic)
}
func (m *RecognitionConfig) XXX_Merge(src proto.Message) {
xxx_messageInfo_RecognitionConfig.Merge(m, src)
}
func (m *RecognitionConfig) XXX_Size() int {
return xxx_messageInfo_RecognitionConfig.Size(m)
}
func (m *RecognitionConfig) XXX_DiscardUnknown() {
xxx_messageInfo_RecognitionConfig.DiscardUnknown(m)
}
var xxx_messageInfo_RecognitionConfig proto.InternalMessageInfo
func (m *RecognitionConfig) GetSpecification() *RecognitionSpec {
if m != nil {
return m.Specification
}
return nil
}
func (m *RecognitionConfig) GetFolderId() string {
if m != nil {
return m.FolderId
}
return ""
}
type RecognitionSpec struct {
AudioEncoding RecognitionSpec_AudioEncoding `protobuf:"varint,1,opt,name=audio_encoding,json=audioEncoding,proto3,enum=yandex.cloud.ai.stt.v2.RecognitionSpec_AudioEncoding" json:"audio_encoding,omitempty"`
// 8000, 16000, 48000 only for pcm
SampleRateHertz int64 `protobuf:"varint,2,opt,name=sample_rate_hertz,json=sampleRateHertz,proto3" json:"sample_rate_hertz,omitempty"`
// code in BCP-47
LanguageCode string `protobuf:"bytes,3,opt,name=language_code,json=languageCode,proto3" json:"language_code,omitempty"`
ProfanityFilter bool `protobuf:"varint,4,opt,name=profanity_filter,json=profanityFilter,proto3" json:"profanity_filter,omitempty"`
Model string `protobuf:"bytes,5,opt,name=model,proto3" json:"model,omitempty"`
// If set true, tentative hypotheses may be returned as they become available (final=false flag)
// If false or omitted, only final=true result(s) are returned.
// Makes sense only for StreamingRecognize requests.
PartialResults bool `protobuf:"varint,7,opt,name=partial_results,json=partialResults,proto3" json:"partial_results,omitempty"`
SingleUtterance bool `protobuf:"varint,8,opt,name=single_utterance,json=singleUtterance,proto3" json:"single_utterance,omitempty"`
// Used only for long running recognize.
AudioChannelCount int64 `protobuf:"varint,9,opt,name=audio_channel_count,json=audioChannelCount,proto3" json:"audio_channel_count,omitempty"`
// This mark allows disable normalization text
RawResults bool `protobuf:"varint,10,opt,name=raw_results,json=rawResults,proto3" json:"raw_results,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *RecognitionSpec) Reset() { *m = RecognitionSpec{} }
func (m *RecognitionSpec) String() string { return proto.CompactTextString(m) }
func (*RecognitionSpec) ProtoMessage() {}
func (*RecognitionSpec) Descriptor() ([]byte, []int) {
return fileDescriptor_44de6807abd10de5, []int{6}
}
func (m *RecognitionSpec) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_RecognitionSpec.Unmarshal(m, b)
}
func (m *RecognitionSpec) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_RecognitionSpec.Marshal(b, m, deterministic)
}
func (m *RecognitionSpec) XXX_Merge(src proto.Message) {
xxx_messageInfo_RecognitionSpec.Merge(m, src)
}
func (m *RecognitionSpec) XXX_Size() int {
return xxx_messageInfo_RecognitionSpec.Size(m)
}
func (m *RecognitionSpec) XXX_DiscardUnknown() {
xxx_messageInfo_RecognitionSpec.DiscardUnknown(m)
}
var xxx_messageInfo_RecognitionSpec proto.InternalMessageInfo
func (m *RecognitionSpec) GetAudioEncoding() RecognitionSpec_AudioEncoding {
if m != nil {
return m.AudioEncoding
}
return RecognitionSpec_AUDIO_ENCODING_UNSPECIFIED
}
func (m *RecognitionSpec) GetSampleRateHertz() int64 {
if m != nil {
return m.SampleRateHertz
}
return 0
}
func (m *RecognitionSpec) GetLanguageCode() string {
if m != nil {
return m.LanguageCode
}
return ""
}
func (m *RecognitionSpec) GetProfanityFilter() bool {
if m != nil {
return m.ProfanityFilter
}
return false
}
func (m *RecognitionSpec) GetModel() string {
if m != nil {
return m.Model
}
return ""
}
func (m *RecognitionSpec) GetPartialResults() bool {
if m != nil {
return m.PartialResults
}
return false
}
func (m *RecognitionSpec) GetSingleUtterance() bool {
if m != nil {
return m.SingleUtterance
}
return false
}
func (m *RecognitionSpec) GetAudioChannelCount() int64 {
if m != nil {
return m.AudioChannelCount
}
return 0
}
func (m *RecognitionSpec) GetRawResults() bool {
if m != nil {
return m.RawResults
}
return false
}
type SpeechRecognitionChunk struct {
Alternatives []*SpeechRecognitionAlternative `protobuf:"bytes,1,rep,name=alternatives,proto3" json:"alternatives,omitempty"`
// This flag shows that the received chunk contains a part of the recognized text that won't be changed.
Final bool `protobuf:"varint,2,opt,name=final,proto3" json:"final,omitempty"`
// This flag shows that the received chunk is the end of an utterance.
EndOfUtterance bool `protobuf:"varint,3,opt,name=end_of_utterance,json=endOfUtterance,proto3" json:"end_of_utterance,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *SpeechRecognitionChunk) Reset() { *m = SpeechRecognitionChunk{} }
func (m *SpeechRecognitionChunk) String() string { return proto.CompactTextString(m) }
func (*SpeechRecognitionChunk) ProtoMessage() {}
func (*SpeechRecognitionChunk) Descriptor() ([]byte, []int) {
return fileDescriptor_44de6807abd10de5, []int{7}
}
func (m *SpeechRecognitionChunk) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_SpeechRecognitionChunk.Unmarshal(m, b)
}
func (m *SpeechRecognitionChunk) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_SpeechRecognitionChunk.Marshal(b, m, deterministic)
}
func (m *SpeechRecognitionChunk) XXX_Merge(src proto.Message) {
xxx_messageInfo_SpeechRecognitionChunk.Merge(m, src)
}
func (m *SpeechRecognitionChunk) XXX_Size() int {
return xxx_messageInfo_SpeechRecognitionChunk.Size(m)
}
func (m *SpeechRecognitionChunk) XXX_DiscardUnknown() {
xxx_messageInfo_SpeechRecognitionChunk.DiscardUnknown(m)
}
var xxx_messageInfo_SpeechRecognitionChunk proto.InternalMessageInfo
func (m *SpeechRecognitionChunk) GetAlternatives() []*SpeechRecognitionAlternative {
if m != nil {
return m.Alternatives
}
return nil
}
func (m *SpeechRecognitionChunk) GetFinal() bool {
if m != nil {
return m.Final
}
return false
}
func (m *SpeechRecognitionChunk) GetEndOfUtterance() bool {
if m != nil {
return m.EndOfUtterance
}
return false
}
type SpeechRecognitionResult struct {
Alternatives []*SpeechRecognitionAlternative `protobuf:"bytes,1,rep,name=alternatives,proto3" json:"alternatives,omitempty"`
ChannelTag int64 `protobuf:"varint,2,opt,name=channel_tag,json=channelTag,proto3" json:"channel_tag,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *SpeechRecognitionResult) Reset() { *m = SpeechRecognitionResult{} }
func (m *SpeechRecognitionResult) String() string { return proto.CompactTextString(m) }
func (*SpeechRecognitionResult) ProtoMessage() {}
func (*SpeechRecognitionResult) Descriptor() ([]byte, []int) {
return fileDescriptor_44de6807abd10de5, []int{8}
}
func (m *SpeechRecognitionResult) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_SpeechRecognitionResult.Unmarshal(m, b)
}
func (m *SpeechRecognitionResult) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_SpeechRecognitionResult.Marshal(b, m, deterministic)
}
func (m *SpeechRecognitionResult) XXX_Merge(src proto.Message) {
xxx_messageInfo_SpeechRecognitionResult.Merge(m, src)
}
func (m *SpeechRecognitionResult) XXX_Size() int {
return xxx_messageInfo_SpeechRecognitionResult.Size(m)
}
func (m *SpeechRecognitionResult) XXX_DiscardUnknown() {
xxx_messageInfo_SpeechRecognitionResult.DiscardUnknown(m)
}
var xxx_messageInfo_SpeechRecognitionResult proto.InternalMessageInfo
func (m *SpeechRecognitionResult) GetAlternatives() []*SpeechRecognitionAlternative {
if m != nil {
return m.Alternatives
}
return nil
}
func (m *SpeechRecognitionResult) GetChannelTag() int64 {
if m != nil {
return m.ChannelTag
}
return 0
}
type SpeechRecognitionAlternative struct {
Text string `protobuf:"bytes,1,opt,name=text,proto3" json:"text,omitempty"`
Confidence float32 `protobuf:"fixed32,2,opt,name=confidence,proto3" json:"confidence,omitempty"`
Words []*WordInfo `protobuf:"bytes,3,rep,name=words,proto3" json:"words,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *SpeechRecognitionAlternative) Reset() { *m = SpeechRecognitionAlternative{} }
func (m *SpeechRecognitionAlternative) String() string { return proto.CompactTextString(m) }
func (*SpeechRecognitionAlternative) ProtoMessage() {}
func (*SpeechRecognitionAlternative) Descriptor() ([]byte, []int) {
return fileDescriptor_44de6807abd10de5, []int{9}
}
func (m *SpeechRecognitionAlternative) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_SpeechRecognitionAlternative.Unmarshal(m, b)
}
func (m *SpeechRecognitionAlternative) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_SpeechRecognitionAlternative.Marshal(b, m, deterministic)
}
func (m *SpeechRecognitionAlternative) XXX_Merge(src proto.Message) {
xxx_messageInfo_SpeechRecognitionAlternative.Merge(m, src)
}
func (m *SpeechRecognitionAlternative) XXX_Size() int {
return xxx_messageInfo_SpeechRecognitionAlternative.Size(m)
}
func (m *SpeechRecognitionAlternative) XXX_DiscardUnknown() {
xxx_messageInfo_SpeechRecognitionAlternative.DiscardUnknown(m)
}
var xxx_messageInfo_SpeechRecognitionAlternative proto.InternalMessageInfo
func (m *SpeechRecognitionAlternative) GetText() string {
if m != nil {
return m.Text
}
return ""
}
func (m *SpeechRecognitionAlternative) GetConfidence() float32 {
if m != nil {
return m.Confidence
}
return 0
}
func (m *SpeechRecognitionAlternative) GetWords() []*WordInfo {
if m != nil {
return m.Words
}
return nil
}
type WordInfo struct {
StartTime *duration.Duration `protobuf:"bytes,1,opt,name=start_time,json=startTime,proto3" json:"start_time,omitempty"`
EndTime *duration.Duration `protobuf:"bytes,2,opt,name=end_time,json=endTime,proto3" json:"end_time,omitempty"`
Word string `protobuf:"bytes,3,opt,name=word,proto3" json:"word,omitempty"`
Confidence float32 `protobuf:"fixed32,4,opt,name=confidence,proto3" json:"confidence,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *WordInfo) Reset() { *m = WordInfo{} }
func (m *WordInfo) String() string { return proto.CompactTextString(m) }
func (*WordInfo) ProtoMessage() {}
func (*WordInfo) Descriptor() ([]byte, []int) {
return fileDescriptor_44de6807abd10de5, []int{10}
}
func (m *WordInfo) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_WordInfo.Unmarshal(m, b)
}
func (m *WordInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_WordInfo.Marshal(b, m, deterministic)
}
func (m *WordInfo) XXX_Merge(src proto.Message) {
xxx_messageInfo_WordInfo.Merge(m, src)
}
func (m *WordInfo) XXX_Size() int {
return xxx_messageInfo_WordInfo.Size(m)
}
func (m *WordInfo) XXX_DiscardUnknown() {
xxx_messageInfo_WordInfo.DiscardUnknown(m)
}
var xxx_messageInfo_WordInfo proto.InternalMessageInfo
func (m *WordInfo) GetStartTime() *duration.Duration {
if m != nil {
return m.StartTime
}
return nil
}
func (m *WordInfo) GetEndTime() *duration.Duration {
if m != nil {
return m.EndTime
}
return nil
}
func (m *WordInfo) GetWord() string {
if m != nil {
return m.Word
}
return ""
}
func (m *WordInfo) GetConfidence() float32 {
if m != nil {
return m.Confidence
}
return 0
}
func init() {
proto.RegisterEnum("yandex.cloud.ai.stt.v2.RecognitionSpec_AudioEncoding", RecognitionSpec_AudioEncoding_name, RecognitionSpec_AudioEncoding_value)
proto.RegisterType((*LongRunningRecognitionRequest)(nil), "yandex.cloud.ai.stt.v2.LongRunningRecognitionRequest")
proto.RegisterType((*LongRunningRecognitionResponse)(nil), "yandex.cloud.ai.stt.v2.LongRunningRecognitionResponse")
proto.RegisterType((*StreamingRecognitionRequest)(nil), "yandex.cloud.ai.stt.v2.StreamingRecognitionRequest")
proto.RegisterType((*StreamingRecognitionResponse)(nil), "yandex.cloud.ai.stt.v2.StreamingRecognitionResponse")
proto.RegisterType((*RecognitionAudio)(nil), "yandex.cloud.ai.stt.v2.RecognitionAudio")
proto.RegisterType((*RecognitionConfig)(nil), "yandex.cloud.ai.stt.v2.RecognitionConfig")
proto.RegisterType((*RecognitionSpec)(nil), "yandex.cloud.ai.stt.v2.RecognitionSpec")
proto.RegisterType((*SpeechRecognitionChunk)(nil), "yandex.cloud.ai.stt.v2.SpeechRecognitionChunk")
proto.RegisterType((*SpeechRecognitionResult)(nil), "yandex.cloud.ai.stt.v2.SpeechRecognitionResult")
proto.RegisterType((*SpeechRecognitionAlternative)(nil), "yandex.cloud.ai.stt.v2.SpeechRecognitionAlternative")
proto.RegisterType((*WordInfo)(nil), "yandex.cloud.ai.stt.v2.WordInfo")
}
func init() {
proto.RegisterFile("yandex/cloud/ai/stt/v2/stt_service.proto", fileDescriptor_44de6807abd10de5)
}
var fileDescriptor_44de6807abd10de5 = []byte{
// 1073 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x56, 0x4f, 0x6f, 0xdb, 0x36,
0x14, 0x8f, 0xec, 0xfc, 0x71, 0x5e, 0x9c, 0xc4, 0x61, 0x8b, 0xd6, 0x73, 0xbb, 0xd4, 0x53, 0xb1,
0xd5, 0x0d, 0x50, 0x69, 0x73, 0xb3, 0x62, 0xd8, 0x80, 0x02, 0x89, 0xf3, 0xcf, 0x43, 0x1b, 0x07,
0x74, 0x83, 0x0d, 0x43, 0x01, 0x81, 0x91, 0x28, 0x85, 0x98, 0x4c, 0x6a, 0x12, 0x95, 0xb4, 0xb9,
0x0c, 0x18, 0xd0, 0xcb, 0xae, 0xdb, 0x79, 0x87, 0x7d, 0x80, 0x1d, 0xfa, 0x19, 0xf6, 0x09, 0xb6,
0xe3, 0xae, 0xfb, 0x0e, 0xbb, 0x0e, 0x22, 0xa5, 0xa4, 0x76, 0xed, 0x36, 0x1b, 0xd0, 0x93, 0xc4,
0x1f, 0xdf, 0xef, 0xf1, 0xbd, 0xdf, 0x23, 0xf9, 0x08, 0xad, 0xe7, 0x84, 0x7b, 0xf4, 0x99, 0xed,
0x86, 0x22, 0xf5, 0x6c, 0xc2, 0xec, 0x44, 0x4a, 0xfb, 0xa4, 0x9d, 0x7d, 0x9c, 0x84, 0xc6, 0x27,
0xcc, 0xa5, 0x56, 0x14, 0x0b, 0x29, 0xd0, 0x35, 0x6d, 0x69, 0x29, 0x4b, 0x8b, 0x30, 0x2b, 0x91,
0xd2, 0x3a, 0x69, 0x37, 0x6e, 0x06, 0x42, 0x04, 0x21, 0xb5, 0x49, 0xc4, 0x6c, 0xc2, 0xb9, 0x90,
0x44, 0x32, 0xc1, 0x13, 0xcd, 0x6a, 0xac, 0xe6, 0xb3, 0x6a, 0x74, 0x94, 0xfa, 0xb6, 0x97, 0xc6,
0xca, 0x20, 0x9f, 0x6f, 0x0e, 0xaf, 0x1f, 0x31, 0x5b, 0x44, 0x74, 0xc8, 0xe2, 0xa3, 0x21, 0x8b,
0xf3, 0xd9, 0x51, 0x3b, 0xf3, 0x57, 0x03, 0xde, 0x7f, 0x24, 0x78, 0x80, 0x53, 0xce, 0x19, 0x0f,
0x30, 0x75, 0x45, 0xc0, 0x59, 0x66, 0x80, 0xe9, 0x77, 0x29, 0x4d, 0x24, 0xda, 0x80, 0x59, 0x57,
0x70, 0x9f, 0x05, 0x75, 0xa3, 0x69, 0xb4, 0x16, 0xda, 0x77, 0xad, 0xf1, 0x29, 0x59, 0xaf, 0x70,
0x3b, 0x8a, 0x80, 0x73, 0x22, 0x7a, 0x08, 0x33, 0x24, 0xf5, 0x98, 0xa8, 0x97, 0x94, 0x87, 0xd6,
0x25, 0x3c, 0x6c, 0x64, 0xf6, 0x58, 0xd3, 0x4c, 0x06, 0xab, 0x93, 0x62, 0x4c, 0x22, 0xc1, 0x13,
0x8a, 0x76, 0x61, 0xd6, 0x3d, 0x4e, 0xf9, 0xb7, 0x49, 0xdd, 0x68, 0x96, 0x5b, 0x0b, 0x6d, 0x7b,
0xd2, 0x12, 0xfd, 0x88, 0x52, 0xf7, 0x78, 0xd8, 0x45, 0x1a, 0x4a, 0x9c, 0xd3, 0xcd, 0x5f, 0x0c,
0xb8, 0xd1, 0x97, 0x31, 0x25, 0x83, 0xf1, 0x6a, 0x74, 0xfe, 0xb7, 0x1a, 0x7b, 0x53, 0xe7, 0x7a,
0x7c, 0x08, 0x8b, 0x2a, 0x31, 0xc7, 0x15, 0x5c, 0x52, 0x2e, 0x95, 0x2e, 0xd5, 0xbd, 0x29, 0x5c,
0x55, 0x70, 0x47, 0xa3, 0x9b, 0x57, 0x60, 0x25, 0x29, 0x42, 0x71, 0x62, 0x1d, 0x80, 0xf9, 0xc2,
0x80, 0x9b, 0xe3, 0x03, 0xcc, 0xa5, 0xd8, 0x19, 0x91, 0xc2, 0xba, 0xb4, 0x14, 0x9d, 0x8c, 0x56,
0x28, 0xf1, 0xe5, 0x74, 0xa5, 0x54, 0x2b, 0xe3, 0xeb, 0x94, 0x7b, 0x8e, 0xf0, 0x9d, 0x84, 0xf1,
0x20, 0xa4, 0x4e, 0x2a, 0x25, 0x8d, 0x09, 0x77, 0xa9, 0x89, 0xa1, 0x36, 0x5a, 0x2e, 0xd4, 0x80,
0xb9, 0x22, 0x23, 0x23, 0xcf, 0xa8, 0x00, 0x10, 0x82, 0x72, 0x1a, 0x33, 0x95, 0xe9, 0xfc, 0xde,
0x14, 0xce, 0x06, 0x9b, 0x4b, 0xa0, 0x13, 0x76, 0x12, 0x91, 0xc6, 0x2e, 0x35, 0xbf, 0x87, 0x95,
0xd7, 0x64, 0x43, 0x8f, 0x61, 0x31, 0x89, 0xa8, 0xcb, 0x7c, 0xe6, 0xaa, 0x8d, 0x9b, 0x0b, 0x7f,
0xe7, 0x12, 0xc2, 0xf7, 0x23, 0xea, 0xe2, 0x61, 0x36, 0xba, 0x01, 0xf3, 0xbe, 0x08, 0x3d, 0x1a,
0x3b, 0xcc, 0xd3, 0xd1, 0xe0, 0x8a, 0x06, 0xba, 0x9e, 0xf9, 0x4f, 0x19, 0x96, 0x47, 0xf8, 0xe8,
0x29, 0x2c, 0xe9, 0x20, 0x29, 0x77, 0x85, 0xc7, 0xb8, 0xae, 0xfc, 0x52, 0xfb, 0xd3, 0x4b, 0x06,
0x60, 0x29, 0x6d, 0xb6, 0x73, 0x32, 0xd6, 0x95, 0x2f, 0x86, 0x68, 0x0d, 0x56, 0x12, 0x32, 0x88,
0x42, 0xea, 0xc4, 0x44, 0x52, 0xe7, 0x98, 0xc6, 0xf2, 0x4c, 0x85, 0x55, 0xc6, 0xcb, 0x7a, 0x02,
0x13, 0x49, 0xf7, 0x32, 0x18, 0xdd, 0x86, 0xc5, 0x90, 0xf0, 0x20, 0x25, 0x01, 0x75, 0x5c, 0xe1,
0xd1, 0x7a, 0x59, 0x85, 0x5f, 0x2d, 0xc0, 0x8e, 0xf0, 0x28, 0xba, 0x0b, 0xb5, 0x28, 0x16, 0x3e,
0xe1, 0x4c, 0x3e, 0x77, 0x7c, 0x16, 0x4a, 0x1a, 0xd7, 0xa7, 0x9b, 0x46, 0xab, 0x82, 0x97, 0xcf,
0xf1, 0x1d, 0x05, 0xa3, 0xab, 0x30, 0x33, 0x10, 0x1e, 0x0d, 0xeb, 0x33, 0xca, 0x8f, 0x1e, 0xa0,
0x3b, 0xb0, 0x1c, 0x91, 0x58, 0x32, 0x12, 0x3a, 0xb1, 0x3a, 0x1b, 0x49, 0x7d, 0x4e, 0xf1, 0x97,
0x72, 0x58, 0x9f, 0x98, 0x24, 0x5b, 0x69, 0x74, 0x57, 0xd4, 0x2b, 0x7a, 0x25, 0x8d, 0x1f, 0x16,
0x30, 0xb2, 0xe0, 0x4a, 0xbe, 0xe1, 0x8f, 0x09, 0xe7, 0x34, 0x74, 0x5c, 0x91, 0x72, 0x59, 0x9f,
0x57, 0x79, 0xae, 0xe8, 0x4d, 0xaf, 0x67, 0x3a, 0xd9, 0x04, 0xba, 0x05, 0x0b, 0x31, 0x39, 0x3d,
0x5f, 0x1f, 0x94, 0x57, 0x88, 0xc9, 0x69, 0xbe, 0xb6, 0xd9, 0x83, 0xc5, 0x21, 0x59, 0xd1, 0x2a,
0x34, 0x36, 0x0e, 0xb7, 0xba, 0x3d, 0x67, 0x7b, 0xbf, 0xd3, 0xdb, 0xea, 0xee, 0xef, 0x3a, 0x87,
0xfb, 0xfd, 0x83, 0xed, 0x4e, 0x77, 0xa7, 0xbb, 0xbd, 0x55, 0x9b, 0x42, 0x35, 0xa8, 0x3e, 0xea,
0xee, 0x6f, 0x6f, 0xe0, 0x4f, 0x1e, 0x38, 0x07, 0x9d, 0xc7, 0x35, 0x03, 0x55, 0xa1, 0xd2, 0xdb,
0xdd, 0x75, 0x7a, 0x07, 0x87, 0xfd, 0x5a, 0xc9, 0x7c, 0x69, 0xc0, 0xb5, 0xf1, 0x07, 0x02, 0x7d,
0x0d, 0x55, 0x92, 0xe9, 0xc5, 0x89, 0x64, 0x27, 0xb4, 0x38, 0x56, 0xeb, 0x97, 0x3e, 0x56, 0x1b,
0x17, 0x64, 0x3c, 0xe4, 0x29, 0x2b, 0x80, 0xcf, 0x38, 0x09, 0x55, 0xc1, 0x2b, 0x58, 0x0f, 0x50,
0x0b, 0x6a, 0xf9, 0xa1, 0xbb, 0xd0, 0xb5, 0xac, 0x2b, 0x40, 0xb9, 0xd7, 0xf3, 0xcf, 0x65, 0x35,
0x7f, 0x36, 0xe0, 0xfa, 0x84, 0x0b, 0xed, 0x1d, 0x46, 0x7d, 0x0b, 0x16, 0x8a, 0x32, 0x4a, 0x12,
0xe4, 0x9b, 0x15, 0x72, 0xe8, 0x09, 0x09, 0xcc, 0x1f, 0xb3, 0x2b, 0xea, 0x0d, 0xfe, 0x10, 0x82,
0x69, 0x49, 0x9f, 0xe9, 0x4b, 0x62, 0x1e, 0xab, 0x7f, 0xb4, 0x0a, 0xa0, 0x6e, 0x47, 0x8f, 0x66,
0xf9, 0x66, 0x4e, 0x4b, 0xf8, 0x15, 0x04, 0x3d, 0x80, 0x99, 0x53, 0x11, 0x7b, 0x49, 0xbd, 0xac,
0x12, 0x69, 0x4e, 0x4a, 0xe4, 0x2b, 0x11, 0x7b, 0x5d, 0xee, 0x0b, 0xac, 0xcd, 0xcd, 0xdf, 0x0c,
0xa8, 0x14, 0x18, 0xfa, 0x0c, 0x20, 0x91, 0x24, 0x96, 0x8e, 0x64, 0x03, 0x9a, 0x5f, 0x24, 0xef,
0x59, 0xba, 0xd9, 0x5a, 0x45, 0xb3, 0xb5, 0xb6, 0xf2, 0x66, 0x8b, 0xe7, 0x95, 0xf1, 0x13, 0x36,
0xa0, 0x68, 0x1d, 0x2a, 0x59, 0x51, 0x14, 0xaf, 0xf4, 0x36, 0xde, 0x1c, 0xe5, 0x9e, 0x62, 0x21,
0x98, 0xce, 0xa2, 0xc8, 0x0f, 0xaa, 0xfa, 0x1f, 0x49, 0x74, 0x7a, 0x34, 0xd1, 0xf6, 0x5f, 0x25,
0x80, 0xbe, 0x94, 0x7d, 0xfd, 0x8c, 0x40, 0xbf, 0x1b, 0x70, 0xf5, 0xf5, 0xe6, 0x77, 0x46, 0xd1,
0xc4, 0xfb, 0xe7, 0x8d, 0xed, 0xbc, 0xf1, 0xc1, 0x30, 0xed, 0xe2, 0x3d, 0xd0, 0x2b, 0xfe, 0x4c,
0xfc, 0xf2, 0x8f, 0xb5, 0x26, 0x7a, 0x4b, 0xcb, 0xfd, 0xe1, 0xcf, 0xbf, 0x7f, 0x2a, 0xb5, 0xcc,
0xdb, 0x76, 0xa2, 0x2a, 0x5d, 0xbc, 0x80, 0xc2, 0x31, 0xa1, 0x7e, 0x6e, 0xac, 0xa1, 0x17, 0x06,
0xa0, 0xd1, 0xb6, 0x75, 0x46, 0xd1, 0xfd, 0x89, 0xfb, 0x71, 0x72, 0x0f, 0x6e, 0xac, 0xff, 0x37,
0x92, 0x8e, 0xd7, 0x9c, 0x6a, 0x19, 0x1f, 0x1b, 0x9b, 0x4f, 0xa1, 0x31, 0x4c, 0x8e, 0xd8, 0x85,
0x83, 0x6f, 0x1e, 0x06, 0x4c, 0x1e, 0xa7, 0x47, 0x96, 0x2b, 0x06, 0xb6, 0x36, 0xbb, 0xa7, 0x1f,
0x50, 0x81, 0xb8, 0x17, 0x50, 0xae, 0x2a, 0x6d, 0x8f, 0x7f, 0xfb, 0x7d, 0x91, 0x48, 0x79, 0x34,
0xab, 0x2c, 0xee, 0xff, 0x1b, 0x00, 0x00, 0xff, 0xff, 0x80, 0x2d, 0x0a, 0x7e, 0x20, 0x0a, 0x00,
0x00,
}
// Reference imports to suppress errors if they are not otherwise used.
var _ context.Context
var _ grpc.ClientConnInterface
// This is a compile-time assertion to ensure that this generated file
// is compatible with the grpc package it is being compiled against.
const _ = grpc.SupportPackageIsVersion6
// SttServiceClient is the client API for SttService service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type SttServiceClient interface {
LongRunningRecognize(ctx context.Context, in *LongRunningRecognitionRequest, opts ...grpc.CallOption) (*operation.Operation, error)
StreamingRecognize(ctx context.Context, opts ...grpc.CallOption) (SttService_StreamingRecognizeClient, error)
}
type sttServiceClient struct {
cc grpc.ClientConnInterface
}
func NewSttServiceClient(cc grpc.ClientConnInterface) SttServiceClient {
return &sttServiceClient{cc}
}
func (c *sttServiceClient) LongRunningRecognize(ctx context.Context, in *LongRunningRecognitionRequest, opts ...grpc.CallOption) (*operation.Operation, error) {
out := new(operation.Operation)
err := c.cc.Invoke(ctx, "/yandex.cloud.ai.stt.v2.SttService/LongRunningRecognize", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *sttServiceClient) StreamingRecognize(ctx context.Context, opts ...grpc.CallOption) (SttService_StreamingRecognizeClient, error) {
stream, err := c.cc.NewStream(ctx, &_SttService_serviceDesc.Streams[0], "/yandex.cloud.ai.stt.v2.SttService/StreamingRecognize", opts...)
if err != nil {
return nil, err
}
x := &sttServiceStreamingRecognizeClient{stream}
return x, nil
}
type SttService_StreamingRecognizeClient interface {
Send(*StreamingRecognitionRequest) error
Recv() (*StreamingRecognitionResponse, error)
grpc.ClientStream
}
type sttServiceStreamingRecognizeClient struct {
grpc.ClientStream
}
func (x *sttServiceStreamingRecognizeClient) Send(m *StreamingRecognitionRequest) error {
return x.ClientStream.SendMsg(m)
}
func (x *sttServiceStreamingRecognizeClient) Recv() (*StreamingRecognitionResponse, error) {
m := new(StreamingRecognitionResponse)
if err := x.ClientStream.RecvMsg(m); err != nil {
return nil, err
}
return m, nil
}
// SttServiceServer is the server API for SttService service.
type SttServiceServer interface {
LongRunningRecognize(context.Context, *LongRunningRecognitionRequest) (*operation.Operation, error)
StreamingRecognize(SttService_StreamingRecognizeServer) error
}
// UnimplementedSttServiceServer can be embedded to have forward compatible implementations.
type UnimplementedSttServiceServer struct {
}
func (*UnimplementedSttServiceServer) LongRunningRecognize(ctx context.Context, req *LongRunningRecognitionRequest) (*operation.Operation, error) {
return nil, status.Errorf(codes.Unimplemented, "method LongRunningRecognize not implemented")
}
func (*UnimplementedSttServiceServer) StreamingRecognize(srv SttService_StreamingRecognizeServer) error {
return status.Errorf(codes.Unimplemented, "method StreamingRecognize not implemented")
}
func RegisterSttServiceServer(s *grpc.Server, srv SttServiceServer) {
s.RegisterService(&_SttService_serviceDesc, srv)
}
func _SttService_LongRunningRecognize_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(LongRunningRecognitionRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(SttServiceServer).LongRunningRecognize(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/yandex.cloud.ai.stt.v2.SttService/LongRunningRecognize",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(SttServiceServer).LongRunningRecognize(ctx, req.(*LongRunningRecognitionRequest))
}
return interceptor(ctx, in, info, handler)
}
func _SttService_StreamingRecognize_Handler(srv interface{}, stream grpc.ServerStream) error {
return srv.(SttServiceServer).StreamingRecognize(&sttServiceStreamingRecognizeServer{stream})
}
type SttService_StreamingRecognizeServer interface {
Send(*StreamingRecognitionResponse) error
Recv() (*StreamingRecognitionRequest, error)
grpc.ServerStream
}
type sttServiceStreamingRecognizeServer struct {
grpc.ServerStream
}
func (x *sttServiceStreamingRecognizeServer) Send(m *StreamingRecognitionResponse) error {
return x.ServerStream.SendMsg(m)
}
func (x *sttServiceStreamingRecognizeServer) Recv() (*StreamingRecognitionRequest, error) {
m := new(StreamingRecognitionRequest)
if err := x.ServerStream.RecvMsg(m); err != nil {
return nil, err
}
return m, nil
}
var _SttService_serviceDesc = grpc.ServiceDesc{
ServiceName: "yandex.cloud.ai.stt.v2.SttService",
HandlerType: (*SttServiceServer)(nil),
Methods: []grpc.MethodDesc{
{
MethodName: "LongRunningRecognize",
Handler: _SttService_LongRunningRecognize_Handler,
},
},
Streams: []grpc.StreamDesc{
{
StreamName: "StreamingRecognize",
Handler: _SttService_StreamingRecognize_Handler,
ServerStreams: true,
ClientStreams: true,
},
},
Metadata: "yandex/cloud/ai/stt/v2/stt_service.proto",
}

151
vendor/github.com/yandex-cloud/go-genproto/yandex/cloud/ai/stt/v2/stt_service.pbext.go generated vendored Normal file
View file

@ -0,0 +1,151 @@
// Code generated by protoc-gen-goext. DO NOT EDIT.
package stt
import (
duration "github.com/golang/protobuf/ptypes/duration"
)
func (m *LongRunningRecognitionRequest) SetConfig(v *RecognitionConfig) {
m.Config = v
}
func (m *LongRunningRecognitionRequest) SetAudio(v *RecognitionAudio) {
m.Audio = v
}
func (m *LongRunningRecognitionResponse) SetChunks(v []*SpeechRecognitionResult) {
m.Chunks = v
}
type StreamingRecognitionRequest_StreamingRequest = isStreamingRecognitionRequest_StreamingRequest
func (m *StreamingRecognitionRequest) SetStreamingRequest(v StreamingRecognitionRequest_StreamingRequest) {
m.StreamingRequest = v
}
func (m *StreamingRecognitionRequest) SetConfig(v *RecognitionConfig) {
m.StreamingRequest = &StreamingRecognitionRequest_Config{
Config: v,
}
}
func (m *StreamingRecognitionRequest) SetAudioContent(v []byte) {
m.StreamingRequest = &StreamingRecognitionRequest_AudioContent{
AudioContent: v,
}
}
func (m *StreamingRecognitionResponse) SetChunks(v []*SpeechRecognitionChunk) {
m.Chunks = v
}
type RecognitionAudio_AudioSource = isRecognitionAudio_AudioSource
func (m *RecognitionAudio) SetAudioSource(v RecognitionAudio_AudioSource) {
m.AudioSource = v
}
func (m *RecognitionAudio) SetContent(v []byte) {
m.AudioSource = &RecognitionAudio_Content{
Content: v,
}
}
func (m *RecognitionAudio) SetUri(v string) {
m.AudioSource = &RecognitionAudio_Uri{
Uri: v,
}
}
func (m *RecognitionConfig) SetSpecification(v *RecognitionSpec) {
m.Specification = v
}
func (m *RecognitionConfig) SetFolderId(v string) {
m.FolderId = v
}
func (m *RecognitionSpec) SetAudioEncoding(v RecognitionSpec_AudioEncoding) {
m.AudioEncoding = v
}
func (m *RecognitionSpec) SetSampleRateHertz(v int64) {
m.SampleRateHertz = v
}
func (m *RecognitionSpec) SetLanguageCode(v string) {
m.LanguageCode = v
}
func (m *RecognitionSpec) SetProfanityFilter(v bool) {
m.ProfanityFilter = v
}
func (m *RecognitionSpec) SetModel(v string) {
m.Model = v
}
func (m *RecognitionSpec) SetPartialResults(v bool) {
m.PartialResults = v
}
func (m *RecognitionSpec) SetSingleUtterance(v bool) {
m.SingleUtterance = v
}
func (m *RecognitionSpec) SetAudioChannelCount(v int64) {
m.AudioChannelCount = v
}
func (m *RecognitionSpec) SetRawResults(v bool) {
m.RawResults = v
}
func (m *SpeechRecognitionChunk) SetAlternatives(v []*SpeechRecognitionAlternative) {
m.Alternatives = v
}
func (m *SpeechRecognitionChunk) SetFinal(v bool) {
m.Final = v
}
func (m *SpeechRecognitionChunk) SetEndOfUtterance(v bool) {
m.EndOfUtterance = v
}
func (m *SpeechRecognitionResult) SetAlternatives(v []*SpeechRecognitionAlternative) {
m.Alternatives = v
}
func (m *SpeechRecognitionResult) SetChannelTag(v int64) {
m.ChannelTag = v
}
func (m *SpeechRecognitionAlternative) SetText(v string) {
m.Text = v
}
func (m *SpeechRecognitionAlternative) SetConfidence(v float32) {
m.Confidence = v
}
func (m *SpeechRecognitionAlternative) SetWords(v []*WordInfo) {
m.Words = v
}
func (m *WordInfo) SetStartTime(v *duration.Duration) {
m.StartTime = v
}
func (m *WordInfo) SetEndTime(v *duration.Duration) {
m.EndTime = v
}
func (m *WordInfo) SetWord(v string) {
m.Word = v
}
func (m *WordInfo) SetConfidence(v float32) {
m.Confidence = v
}

148
vendor/github.com/yandex-cloud/go-genproto/yandex/cloud/ai/translate/v2/translation.pb.go generated vendored Normal file
View file

@ -0,0 +1,148 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
// source: yandex/cloud/ai/translate/v2/translation.proto
package translate
import (
fmt "fmt"
proto "github.com/golang/protobuf/proto"
math "math"
)
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf
// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.ProtoPackageIsVersion3 // please upgrade the proto package
type TranslatedText struct {
// Translated text.
Text string `protobuf:"bytes,1,opt,name=text,proto3" json:"text,omitempty"`
// The language code of the source text.
// Specified in [ISO 639-1](https://en.wikipedia.org/wiki/ISO_639-1) format (for example, `` en ``).
DetectedLanguageCode string `protobuf:"bytes,2,opt,name=detected_language_code,json=detectedLanguageCode,proto3" json:"detected_language_code,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *TranslatedText) Reset() { *m = TranslatedText{} }
func (m *TranslatedText) String() string { return proto.CompactTextString(m) }
func (*TranslatedText) ProtoMessage() {}
func (*TranslatedText) Descriptor() ([]byte, []int) {
return fileDescriptor_a844663219943b98, []int{0}
}
func (m *TranslatedText) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_TranslatedText.Unmarshal(m, b)
}
func (m *TranslatedText) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_TranslatedText.Marshal(b, m, deterministic)
}
func (m *TranslatedText) XXX_Merge(src proto.Message) {
xxx_messageInfo_TranslatedText.Merge(m, src)
}
func (m *TranslatedText) XXX_Size() int {
return xxx_messageInfo_TranslatedText.Size(m)
}
func (m *TranslatedText) XXX_DiscardUnknown() {
xxx_messageInfo_TranslatedText.DiscardUnknown(m)
}
var xxx_messageInfo_TranslatedText proto.InternalMessageInfo
func (m *TranslatedText) GetText() string {
if m != nil {
return m.Text
}
return ""
}
func (m *TranslatedText) GetDetectedLanguageCode() string {
if m != nil {
return m.DetectedLanguageCode
}
return ""
}
type Language struct {
// The language code.
// Specified in [ISO 639-1](https://en.wikipedia.org/wiki/ISO_639-1) format (for example, `` en ``).
Code string `protobuf:"bytes,1,opt,name=code,proto3" json:"code,omitempty"`
// The name of the language (for example, `` English ``).
Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *Language) Reset() { *m = Language{} }
func (m *Language) String() string { return proto.CompactTextString(m) }
func (*Language) ProtoMessage() {}
func (*Language) Descriptor() ([]byte, []int) {
return fileDescriptor_a844663219943b98, []int{1}
}
func (m *Language) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_Language.Unmarshal(m, b)
}
func (m *Language) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_Language.Marshal(b, m, deterministic)
}
func (m *Language) XXX_Merge(src proto.Message) {
xxx_messageInfo_Language.Merge(m, src)
}
func (m *Language) XXX_Size() int {
return xxx_messageInfo_Language.Size(m)
}
func (m *Language) XXX_DiscardUnknown() {
xxx_messageInfo_Language.DiscardUnknown(m)
}
var xxx_messageInfo_Language proto.InternalMessageInfo
func (m *Language) GetCode() string {
if m != nil {
return m.Code
}
return ""
}
func (m *Language) GetName() string {
if m != nil {
return m.Name
}
return ""
}
func init() {
proto.RegisterType((*TranslatedText)(nil), "yandex.cloud.ai.translate.v2.TranslatedText")
proto.RegisterType((*Language)(nil), "yandex.cloud.ai.translate.v2.Language")
}
func init() {
proto.RegisterFile("yandex/cloud/ai/translate/v2/translation.proto", fileDescriptor_a844663219943b98)
}
var fileDescriptor_a844663219943b98 = []byte{
// 217 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x7c, 0x90, 0xb1, 0x4b, 0xc5, 0x30,
0x10, 0xc6, 0x79, 0x22, 0xa2, 0x19, 0x1c, 0x82, 0xc8, 0x1b, 0x1c, 0x1e, 0x9d, 0x5c, 0x9a, 0x40,
0x75, 0x73, 0xd3, 0x4d, 0x9c, 0xa4, 0x53, 0x97, 0x72, 0x4d, 0x8e, 0x18, 0x68, 0x73, 0xa5, 0x5e,
0x4b, 0xfd, 0xef, 0xa5, 0x69, 0x53, 0xd0, 0xe1, 0x6d, 0xdf, 0x2f, 0xf7, 0xe3, 0xe3, 0x72, 0x42,
0xfd, 0x40, 0xb0, 0x38, 0x6b, 0xd3, 0xd2, 0x68, 0x35, 0x78, 0xcd, 0x03, 0x84, 0xef, 0x16, 0x18,
0xf5, 0x54, 0xec, 0xe0, 0x29, 0xa8, 0x7e, 0x20, 0x26, 0xf9, 0xb0, 0xfa, 0x2a, 0xfa, 0x0a, 0xbc,
0xda, 0x7d, 0x35, 0x15, 0x59, 0x25, 0x6e, 0xcb, 0xc4, 0xb6, 0xc4, 0x99, 0xa5, 0x14, 0x97, 0x8c,
0x33, 0x1f, 0x0f, 0xa7, 0xc3, 0xe3, 0xcd, 0x67, 0xcc, 0xf2, 0x59, 0xdc, 0x5b, 0x64, 0x34, 0x8c,
0xb6, 0x6e, 0x21, 0xb8, 0x11, 0x1c, 0xd6, 0x86, 0x2c, 0x1e, 0x2f, 0xa2, 0x75, 0x97, 0xa6, 0x1f,
0xdb, 0xf0, 0x8d, 0x2c, 0x66, 0x85, 0xb8, 0x4e, 0xbc, 0xb4, 0x46, 0x7f, 0x6b, 0x5d, 0xf2, 0xf2,
0x16, 0xa0, 0x4b, 0x1d, 0x31, 0xbf, 0x06, 0x71, 0xfa, 0xbb, 0x6f, 0xef, 0xff, 0xef, 0x5c, 0xbd,
0x3b, 0xcf, 0x5f, 0x63, 0xa3, 0x0c, 0x75, 0x7a, 0x95, 0xf3, 0xf5, 0x18, 0x8e, 0x72, 0x87, 0x21,
0x7e, 0x5b, 0x9f, 0xbb, 0xd2, 0xcb, 0x0e, 0xcd, 0x55, 0xb4, 0x9f, 0x7e, 0x03, 0x00, 0x00, 0xff,
0xff, 0x10, 0xbd, 0x4e, 0x82, 0x56, 0x01, 0x00, 0x00,
}

19
vendor/github.com/yandex-cloud/go-genproto/yandex/cloud/ai/translate/v2/translation.pbext.go generated vendored Normal file
View file

@ -0,0 +1,19 @@
// Code generated by protoc-gen-goext. DO NOT EDIT.
package translate
func (m *TranslatedText) SetText(v string) {
m.Text = v
}
func (m *TranslatedText) SetDetectedLanguageCode(v string) {
m.DetectedLanguageCode = v
}
func (m *Language) SetCode(v string) {
m.Code = v
}
func (m *Language) SetName(v string) {
m.Name = v
}

774
vendor/github.com/yandex-cloud/go-genproto/yandex/cloud/ai/translate/v2/translation_service.pb.go generated vendored Normal file
View file

@ -0,0 +1,774 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
// source: yandex/cloud/ai/translate/v2/translation_service.proto
package translate
import (
context "context"
fmt "fmt"
proto "github.com/golang/protobuf/proto"
_ "github.com/yandex-cloud/go-genproto/yandex/cloud"
_ "google.golang.org/genproto/googleapis/api/annotations"
grpc "google.golang.org/grpc"
codes "google.golang.org/grpc/codes"
status "google.golang.org/grpc/status"
math "math"
)
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf
// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.ProtoPackageIsVersion3 // please upgrade the proto package
type TranslateRequest_Format int32
const (
TranslateRequest_FORMAT_UNSPECIFIED TranslateRequest_Format = 0
// Text without markup. Default value.
TranslateRequest_PLAIN_TEXT TranslateRequest_Format = 1
// Text in the HTML format.
TranslateRequest_HTML TranslateRequest_Format = 2
)
var TranslateRequest_Format_name = map[int32]string{
0: "FORMAT_UNSPECIFIED",
1: "PLAIN_TEXT",
2: "HTML",
}
var TranslateRequest_Format_value = map[string]int32{
"FORMAT_UNSPECIFIED": 0,
"PLAIN_TEXT": 1,
"HTML": 2,
}
func (x TranslateRequest_Format) String() string {
return proto.EnumName(TranslateRequest_Format_name, int32(x))
}
func (TranslateRequest_Format) EnumDescriptor() ([]byte, []int) {
return fileDescriptor_07212bd16e7bdb8a, []int{0, 0}
}
type TranslateRequest struct {
// The text language to translate from.
// Specified in [ISO 639-1](https://en.wikipedia.org/wiki/ISO_639-1) format (for example, `` ru ``).
//
// Required for translating with glossary.
SourceLanguageCode string `protobuf:"bytes,1,opt,name=source_language_code,json=sourceLanguageCode,proto3" json:"source_language_code,omitempty"`
// The target language to translate the text.
// Specified in [ISO 639-1](https://en.wikipedia.org/wiki/ISO_639-1) format (for example, `` en ``).
TargetLanguageCode string `protobuf:"bytes,2,opt,name=target_language_code,json=targetLanguageCode,proto3" json:"target_language_code,omitempty"`
// Format of the text.
Format TranslateRequest_Format `protobuf:"varint,3,opt,name=format,proto3,enum=yandex.cloud.ai.translate.v2.TranslateRequest_Format" json:"format,omitempty"`
// Array of the strings to translate.
// The maximum total length of all strings is 10000 characters.
Texts []string `protobuf:"bytes,4,rep,name=texts,proto3" json:"texts,omitempty"`
// ID of the folder to which you have access.
// Required for authorization with a user account (see [yandex.cloud.iam.v1.UserAccount] resource).
// Don't specify this field if you make the request on behalf of a service account.
FolderId string `protobuf:"bytes,5,opt,name=folder_id,json=folderId,proto3" json:"folder_id,omitempty"`
// Do not specify this field, custom models are not supported yet.
Model string `protobuf:"bytes,6,opt,name=model,proto3" json:"model,omitempty"`
// Glossary to be applied for the translation. For more information, see [Glossaries](/docs/translate/concepts/glossary).
GlossaryConfig *TranslateGlossaryConfig `protobuf:"bytes,7,opt,name=glossary_config,json=glossaryConfig,proto3" json:"glossary_config,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *TranslateRequest) Reset() { *m = TranslateRequest{} }
func (m *TranslateRequest) String() string { return proto.CompactTextString(m) }
func (*TranslateRequest) ProtoMessage() {}
func (*TranslateRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_07212bd16e7bdb8a, []int{0}
}
func (m *TranslateRequest) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_TranslateRequest.Unmarshal(m, b)
}
func (m *TranslateRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_TranslateRequest.Marshal(b, m, deterministic)
}
func (m *TranslateRequest) XXX_Merge(src proto.Message) {
xxx_messageInfo_TranslateRequest.Merge(m, src)
}
func (m *TranslateRequest) XXX_Size() int {
return xxx_messageInfo_TranslateRequest.Size(m)
}
func (m *TranslateRequest) XXX_DiscardUnknown() {
xxx_messageInfo_TranslateRequest.DiscardUnknown(m)
}
var xxx_messageInfo_TranslateRequest proto.InternalMessageInfo
func (m *TranslateRequest) GetSourceLanguageCode() string {
if m != nil {
return m.SourceLanguageCode
}
return ""
}
func (m *TranslateRequest) GetTargetLanguageCode() string {
if m != nil {
return m.TargetLanguageCode
}
return ""
}
func (m *TranslateRequest) GetFormat() TranslateRequest_Format {
if m != nil {
return m.Format
}
return TranslateRequest_FORMAT_UNSPECIFIED
}
func (m *TranslateRequest) GetTexts() []string {
if m != nil {
return m.Texts
}
return nil
}
func (m *TranslateRequest) GetFolderId() string {
if m != nil {
return m.FolderId
}
return ""
}
func (m *TranslateRequest) GetModel() string {
if m != nil {
return m.Model
}
return ""
}
func (m *TranslateRequest) GetGlossaryConfig() *TranslateGlossaryConfig {
if m != nil {
return m.GlossaryConfig
}
return nil
}
type TranslateGlossaryConfig struct {
// Types that are valid to be assigned to GlossarySource:
// *TranslateGlossaryConfig_GlossaryData
GlossarySource isTranslateGlossaryConfig_GlossarySource `protobuf_oneof:"glossary_source"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *TranslateGlossaryConfig) Reset() { *m = TranslateGlossaryConfig{} }
func (m *TranslateGlossaryConfig) String() string { return proto.CompactTextString(m) }
func (*TranslateGlossaryConfig) ProtoMessage() {}
func (*TranslateGlossaryConfig) Descriptor() ([]byte, []int) {
return fileDescriptor_07212bd16e7bdb8a, []int{1}
}
func (m *TranslateGlossaryConfig) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_TranslateGlossaryConfig.Unmarshal(m, b)
}
func (m *TranslateGlossaryConfig) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_TranslateGlossaryConfig.Marshal(b, m, deterministic)
}
func (m *TranslateGlossaryConfig) XXX_Merge(src proto.Message) {
xxx_messageInfo_TranslateGlossaryConfig.Merge(m, src)
}
func (m *TranslateGlossaryConfig) XXX_Size() int {
return xxx_messageInfo_TranslateGlossaryConfig.Size(m)
}
func (m *TranslateGlossaryConfig) XXX_DiscardUnknown() {
xxx_messageInfo_TranslateGlossaryConfig.DiscardUnknown(m)
}
var xxx_messageInfo_TranslateGlossaryConfig proto.InternalMessageInfo
type isTranslateGlossaryConfig_GlossarySource interface {
isTranslateGlossaryConfig_GlossarySource()
}
type TranslateGlossaryConfig_GlossaryData struct {
GlossaryData *GlossaryData `protobuf:"bytes,1,opt,name=glossary_data,json=glossaryData,proto3,oneof"`
}
func (*TranslateGlossaryConfig_GlossaryData) isTranslateGlossaryConfig_GlossarySource() {}
func (m *TranslateGlossaryConfig) GetGlossarySource() isTranslateGlossaryConfig_GlossarySource {
if m != nil {
return m.GlossarySource
}
return nil
}
func (m *TranslateGlossaryConfig) GetGlossaryData() *GlossaryData {
if x, ok := m.GetGlossarySource().(*TranslateGlossaryConfig_GlossaryData); ok {
return x.GlossaryData
}
return nil
}
// XXX_OneofWrappers is for the internal use of the proto package.
func (*TranslateGlossaryConfig) XXX_OneofWrappers() []interface{} {
return []interface{}{
(*TranslateGlossaryConfig_GlossaryData)(nil),
}
}
type GlossaryData struct {
// Array of text pairs.
//
// The maximum total length of all source texts is 10000 characters.
// The maximum total length of all translated texts is 10000 characters.
GlossaryPairs []*GlossaryPair `protobuf:"bytes,1,rep,name=glossary_pairs,json=glossaryPairs,proto3" json:"glossary_pairs,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *GlossaryData) Reset() { *m = GlossaryData{} }
func (m *GlossaryData) String() string { return proto.CompactTextString(m) }
func (*GlossaryData) ProtoMessage() {}
func (*GlossaryData) Descriptor() ([]byte, []int) {
return fileDescriptor_07212bd16e7bdb8a, []int{2}
}
func (m *GlossaryData) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_GlossaryData.Unmarshal(m, b)
}
func (m *GlossaryData) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_GlossaryData.Marshal(b, m, deterministic)
}
func (m *GlossaryData) XXX_Merge(src proto.Message) {
xxx_messageInfo_GlossaryData.Merge(m, src)
}
func (m *GlossaryData) XXX_Size() int {
return xxx_messageInfo_GlossaryData.Size(m)
}
func (m *GlossaryData) XXX_DiscardUnknown() {
xxx_messageInfo_GlossaryData.DiscardUnknown(m)
}
var xxx_messageInfo_GlossaryData proto.InternalMessageInfo
func (m *GlossaryData) GetGlossaryPairs() []*GlossaryPair {
if m != nil {
return m.GlossaryPairs
}
return nil
}
type GlossaryPair struct {
// Text in the source language.
SourceText string `protobuf:"bytes,1,opt,name=source_text,json=sourceText,proto3" json:"source_text,omitempty"`
// Text in the target language.
TranslatedText string `protobuf:"bytes,2,opt,name=translated_text,json=translatedText,proto3" json:"translated_text,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *GlossaryPair) Reset() { *m = GlossaryPair{} }
func (m *GlossaryPair) String() string { return proto.CompactTextString(m) }
func (*GlossaryPair) ProtoMessage() {}
func (*GlossaryPair) Descriptor() ([]byte, []int) {
return fileDescriptor_07212bd16e7bdb8a, []int{3}
}
func (m *GlossaryPair) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_GlossaryPair.Unmarshal(m, b)
}
func (m *GlossaryPair) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_GlossaryPair.Marshal(b, m, deterministic)
}
func (m *GlossaryPair) XXX_Merge(src proto.Message) {
xxx_messageInfo_GlossaryPair.Merge(m, src)
}
func (m *GlossaryPair) XXX_Size() int {
return xxx_messageInfo_GlossaryPair.Size(m)
}
func (m *GlossaryPair) XXX_DiscardUnknown() {
xxx_messageInfo_GlossaryPair.DiscardUnknown(m)
}
var xxx_messageInfo_GlossaryPair proto.InternalMessageInfo
func (m *GlossaryPair) GetSourceText() string {
if m != nil {
return m.SourceText
}
return ""
}
func (m *GlossaryPair) GetTranslatedText() string {
if m != nil {
return m.TranslatedText
}
return ""
}
type TranslateResponse struct {
// Array of the translations.
Translations []*TranslatedText `protobuf:"bytes,1,rep,name=translations,proto3" json:"translations,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *TranslateResponse) Reset() { *m = TranslateResponse{} }
func (m *TranslateResponse) String() string { return proto.CompactTextString(m) }
func (*TranslateResponse) ProtoMessage() {}
func (*TranslateResponse) Descriptor() ([]byte, []int) {
return fileDescriptor_07212bd16e7bdb8a, []int{4}
}
func (m *TranslateResponse) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_TranslateResponse.Unmarshal(m, b)
}
func (m *TranslateResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_TranslateResponse.Marshal(b, m, deterministic)
}
func (m *TranslateResponse) XXX_Merge(src proto.Message) {
xxx_messageInfo_TranslateResponse.Merge(m, src)
}
func (m *TranslateResponse) XXX_Size() int {
return xxx_messageInfo_TranslateResponse.Size(m)
}
func (m *TranslateResponse) XXX_DiscardUnknown() {
xxx_messageInfo_TranslateResponse.DiscardUnknown(m)
}
var xxx_messageInfo_TranslateResponse proto.InternalMessageInfo
func (m *TranslateResponse) GetTranslations() []*TranslatedText {
if m != nil {
return m.Translations
}
return nil
}
type DetectLanguageRequest struct {
// The text to detect the language for.
Text string `protobuf:"bytes,1,opt,name=text,proto3" json:"text,omitempty"`
// List of the most likely languages. These languages will be given preference when detecting the text language.
// Specified in [ISO 639-1](https://en.wikipedia.org/wiki/ISO_639-1) format (for example, `` ru ``).
//
// To get the list of supported languages, use a [TranslationService.ListLanguages] request.
LanguageCodeHints []string `protobuf:"bytes,2,rep,name=language_code_hints,json=languageCodeHints,proto3" json:"language_code_hints,omitempty"`
// ID of the folder to which you have access.
// Required for authorization with a user account (see [yandex.cloud.iam.v1.UserAccount] resource).
// Don't specify this field if you make the request on behalf of a service account.
FolderId string `protobuf:"bytes,3,opt,name=folder_id,json=folderId,proto3" json:"folder_id,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *DetectLanguageRequest) Reset() { *m = DetectLanguageRequest{} }
func (m *DetectLanguageRequest) String() string { return proto.CompactTextString(m) }
func (*DetectLanguageRequest) ProtoMessage() {}
func (*DetectLanguageRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_07212bd16e7bdb8a, []int{5}
}
func (m *DetectLanguageRequest) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_DetectLanguageRequest.Unmarshal(m, b)
}
func (m *DetectLanguageRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_DetectLanguageRequest.Marshal(b, m, deterministic)
}
func (m *DetectLanguageRequest) XXX_Merge(src proto.Message) {
xxx_messageInfo_DetectLanguageRequest.Merge(m, src)
}
func (m *DetectLanguageRequest) XXX_Size() int {
return xxx_messageInfo_DetectLanguageRequest.Size(m)
}
func (m *DetectLanguageRequest) XXX_DiscardUnknown() {
xxx_messageInfo_DetectLanguageRequest.DiscardUnknown(m)
}
var xxx_messageInfo_DetectLanguageRequest proto.InternalMessageInfo
func (m *DetectLanguageRequest) GetText() string {
if m != nil {
return m.Text
}
return ""
}
func (m *DetectLanguageRequest) GetLanguageCodeHints() []string {
if m != nil {
return m.LanguageCodeHints
}
return nil
}
func (m *DetectLanguageRequest) GetFolderId() string {
if m != nil {
return m.FolderId
}
return ""
}
type DetectLanguageResponse struct {
// The text language in [ISO 639-1](https://en.wikipedia.org/wiki/ISO_639-1) format (for example, `` ru ``).
//
// To get the language name, use a [TranslationService.ListLanguages] request.
LanguageCode string `protobuf:"bytes,1,opt,name=language_code,json=languageCode,proto3" json:"language_code,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *DetectLanguageResponse) Reset() { *m = DetectLanguageResponse{} }
func (m *DetectLanguageResponse) String() string { return proto.CompactTextString(m) }
func (*DetectLanguageResponse) ProtoMessage() {}
func (*DetectLanguageResponse) Descriptor() ([]byte, []int) {
return fileDescriptor_07212bd16e7bdb8a, []int{6}
}
func (m *DetectLanguageResponse) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_DetectLanguageResponse.Unmarshal(m, b)
}
func (m *DetectLanguageResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_DetectLanguageResponse.Marshal(b, m, deterministic)
}
func (m *DetectLanguageResponse) XXX_Merge(src proto.Message) {
xxx_messageInfo_DetectLanguageResponse.Merge(m, src)
}
func (m *DetectLanguageResponse) XXX_Size() int {
return xxx_messageInfo_DetectLanguageResponse.Size(m)
}
func (m *DetectLanguageResponse) XXX_DiscardUnknown() {
xxx_messageInfo_DetectLanguageResponse.DiscardUnknown(m)
}
var xxx_messageInfo_DetectLanguageResponse proto.InternalMessageInfo
func (m *DetectLanguageResponse) GetLanguageCode() string {
if m != nil {
return m.LanguageCode
}
return ""
}
type ListLanguagesRequest struct {
// ID of the folder to which you have access.
// Required for authorization with a user account (see [yandex.cloud.iam.v1.UserAccount] resource).
// Don't specify this field if you make the request on behalf of a service account.
FolderId string `protobuf:"bytes,1,opt,name=folder_id,json=folderId,proto3" json:"folder_id,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *ListLanguagesRequest) Reset() { *m = ListLanguagesRequest{} }
func (m *ListLanguagesRequest) String() string { return proto.CompactTextString(m) }
func (*ListLanguagesRequest) ProtoMessage() {}
func (*ListLanguagesRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_07212bd16e7bdb8a, []int{7}
}
func (m *ListLanguagesRequest) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_ListLanguagesRequest.Unmarshal(m, b)
}
func (m *ListLanguagesRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_ListLanguagesRequest.Marshal(b, m, deterministic)
}
func (m *ListLanguagesRequest) XXX_Merge(src proto.Message) {
xxx_messageInfo_ListLanguagesRequest.Merge(m, src)
}
func (m *ListLanguagesRequest) XXX_Size() int {
return xxx_messageInfo_ListLanguagesRequest.Size(m)
}
func (m *ListLanguagesRequest) XXX_DiscardUnknown() {
xxx_messageInfo_ListLanguagesRequest.DiscardUnknown(m)
}
var xxx_messageInfo_ListLanguagesRequest proto.InternalMessageInfo
func (m *ListLanguagesRequest) GetFolderId() string {
if m != nil {
return m.FolderId
}
return ""
}
type ListLanguagesResponse struct {
// List of supported languages.
Languages []*Language `protobuf:"bytes,1,rep,name=languages,proto3" json:"languages,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *ListLanguagesResponse) Reset() { *m = ListLanguagesResponse{} }
func (m *ListLanguagesResponse) String() string { return proto.CompactTextString(m) }
func (*ListLanguagesResponse) ProtoMessage() {}
func (*ListLanguagesResponse) Descriptor() ([]byte, []int) {
return fileDescriptor_07212bd16e7bdb8a, []int{8}
}
func (m *ListLanguagesResponse) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_ListLanguagesResponse.Unmarshal(m, b)
}
func (m *ListLanguagesResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_ListLanguagesResponse.Marshal(b, m, deterministic)
}
func (m *ListLanguagesResponse) XXX_Merge(src proto.Message) {
xxx_messageInfo_ListLanguagesResponse.Merge(m, src)
}
func (m *ListLanguagesResponse) XXX_Size() int {
return xxx_messageInfo_ListLanguagesResponse.Size(m)
}
func (m *ListLanguagesResponse) XXX_DiscardUnknown() {
xxx_messageInfo_ListLanguagesResponse.DiscardUnknown(m)
}
var xxx_messageInfo_ListLanguagesResponse proto.InternalMessageInfo
func (m *ListLanguagesResponse) GetLanguages() []*Language {
if m != nil {
return m.Languages
}
return nil
}
func init() {
proto.RegisterEnum("yandex.cloud.ai.translate.v2.TranslateRequest_Format", TranslateRequest_Format_name, TranslateRequest_Format_value)
proto.RegisterType((*TranslateRequest)(nil), "yandex.cloud.ai.translate.v2.TranslateRequest")
proto.RegisterType((*TranslateGlossaryConfig)(nil), "yandex.cloud.ai.translate.v2.TranslateGlossaryConfig")
proto.RegisterType((*GlossaryData)(nil), "yandex.cloud.ai.translate.v2.GlossaryData")
proto.RegisterType((*GlossaryPair)(nil), "yandex.cloud.ai.translate.v2.GlossaryPair")
proto.RegisterType((*TranslateResponse)(nil), "yandex.cloud.ai.translate.v2.TranslateResponse")
proto.RegisterType((*DetectLanguageRequest)(nil), "yandex.cloud.ai.translate.v2.DetectLanguageRequest")
proto.RegisterType((*DetectLanguageResponse)(nil), "yandex.cloud.ai.translate.v2.DetectLanguageResponse")
proto.RegisterType((*ListLanguagesRequest)(nil), "yandex.cloud.ai.translate.v2.ListLanguagesRequest")
proto.RegisterType((*ListLanguagesResponse)(nil), "yandex.cloud.ai.translate.v2.ListLanguagesResponse")
}
func init() {
proto.RegisterFile("yandex/cloud/ai/translate/v2/translation_service.proto", fileDescriptor_07212bd16e7bdb8a)
}
var fileDescriptor_07212bd16e7bdb8a = []byte{
// 835 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x94, 0x55, 0x41, 0x6f, 0xe3, 0x44,
0x14, 0x5e, 0x27, 0x69, 0xb6, 0x79, 0x6d, 0xd3, 0xee, 0xd0, 0xdd, 0x9a, 0xa8, 0x40, 0x64, 0xb4,
0xa8, 0xaa, 0x88, 0x1d, 0x27, 0x14, 0x89, 0xd2, 0x80, 0x36, 0x4d, 0x4b, 0x83, 0xd2, 0x25, 0x78,
0x83, 0x84, 0x40, 0x60, 0xcd, 0xc6, 0x53, 0xaf, 0x85, 0xeb, 0x09, 0xf6, 0x24, 0xea, 0x5e, 0x23,
0x71, 0xd9, 0x13, 0x12, 0x57, 0x6e, 0xfc, 0x11, 0x38, 0x91, 0x3b, 0x57, 0x8e, 0x20, 0xf1, 0x33,
0x50, 0x66, 0x6c, 0xc7, 0x8e, 0xd2, 0x6c, 0x7a, 0x9c, 0x99, 0xef, 0x7b, 0xdf, 0xf7, 0xe6, 0xbd,
0x37, 0x03, 0x1f, 0xbe, 0xc4, 0x9e, 0x45, 0x6e, 0xb4, 0xbe, 0x4b, 0x87, 0x96, 0x86, 0x1d, 0x8d,
0xf9, 0xd8, 0x0b, 0x5c, 0xcc, 0x88, 0x36, 0xaa, 0xc5, 0x0b, 0x87, 0x7a, 0x66, 0x40, 0xfc, 0x91,
0xd3, 0x27, 0xea, 0xc0, 0xa7, 0x8c, 0xa2, 0x7d, 0xc1, 0x53, 0x39, 0x4f, 0xc5, 0x8e, 0x1a, 0xf3,
0xd4, 0x51, 0xad, 0xb4, 0x6f, 0x53, 0x6a, 0xbb, 0x44, 0xc3, 0x03, 0x47, 0xc3, 0x9e, 0x47, 0x19,
0x0f, 0x11, 0x08, 0x6e, 0xe9, 0xad, 0x94, 0xe6, 0x08, 0xbb, 0x8e, 0xc5, 0xcf, 0xc3, 0x63, 0x75,
0x55, 0x4b, 0x02, 0xaf, 0xfc, 0x9d, 0x85, 0x9d, 0x5e, 0x04, 0x31, 0xc8, 0x8f, 0x43, 0x12, 0x30,
0xf4, 0x11, 0xec, 0x06, 0x74, 0xe8, 0xf7, 0x89, 0xe9, 0x62, 0xcf, 0x1e, 0x62, 0x9b, 0x98, 0x7d,
0x6a, 0x11, 0x59, 0x2a, 0x4b, 0x07, 0x85, 0xe6, 0xfd, 0x57, 0x13, 0x3d, 0x7b, 0xd2, 0xa8, 0x1b,
0x48, 0x80, 0x3a, 0x21, 0xe6, 0x94, 0x5a, 0x04, 0x35, 0x60, 0x97, 0x61, 0xdf, 0x26, 0x6c, 0x8e,
0x9a, 0xe1, 0xd4, 0x8d, 0xff, 0xfe, 0xd4, 0xa5, 0x98, 0x2e, 0x80, 0x29, 0xfa, 0x25, 0xe4, 0xaf,
0xa8, 0x7f, 0x8d, 0x99, 0x9c, 0x2d, 0x4b, 0x07, 0xc5, 0xda, 0x91, 0xba, 0xec, 0xaa, 0xd4, 0x79,
0xe7, 0xea, 0x39, 0x27, 0x1b, 0x61, 0x10, 0xb4, 0x0f, 0x6b, 0x8c, 0xdc, 0xb0, 0x40, 0xce, 0x95,
0xb3, 0x07, 0x85, 0x66, 0x7e, 0x3c, 0xd1, 0x33, 0x9f, 0x54, 0x0d, 0xb1, 0x89, 0x1e, 0x43, 0xe1,
0x8a, 0xba, 0x16, 0xf1, 0x4d, 0xc7, 0x92, 0xd7, 0xb8, 0xc1, 0xf5, 0x57, 0x13, 0x3d, 0x77, 0xd2,
0x38, 0xaa, 0x1a, 0xeb, 0xe2, 0xa8, 0x6d, 0xa1, 0xb7, 0x61, 0xed, 0x9a, 0x5a, 0xc4, 0x95, 0xf3,
0x73, 0x10, 0xb1, 0x8d, 0xbe, 0x87, 0x6d, 0xdb, 0xa5, 0x41, 0x80, 0xfd, 0x97, 0x66, 0x9f, 0x7a,
0x57, 0x8e, 0x2d, 0xdf, 0x2f, 0x4b, 0x07, 0x1b, 0x2b, 0x9b, 0xff, 0x2c, 0x64, 0x9f, 0x72, 0xb2,
0x51, 0xb4, 0x53, 0x6b, 0xe5, 0x18, 0xf2, 0x22, 0x2d, 0xf4, 0x08, 0xd0, 0xf9, 0x17, 0xc6, 0xe5,
0x93, 0x9e, 0xf9, 0xd5, 0xd3, 0x67, 0xdd, 0xb3, 0xd3, 0xf6, 0x79, 0xfb, 0xac, 0xb5, 0x73, 0x0f,
0x15, 0x01, 0xba, 0x9d, 0x27, 0xed, 0xa7, 0x66, 0xef, 0xec, 0xeb, 0xde, 0x8e, 0x84, 0xd6, 0x21,
0x77, 0xd1, 0xbb, 0xec, 0xec, 0x64, 0x94, 0x9f, 0x24, 0xd8, 0xbb, 0x45, 0x07, 0x7d, 0x09, 0x5b,
0xb1, 0x6f, 0x0b, 0x33, 0xcc, 0xcb, 0xbb, 0x51, 0x3b, 0x5c, 0xee, 0x3a, 0x0a, 0xd2, 0xc2, 0x0c,
0x5f, 0xdc, 0x33, 0x36, 0xed, 0xc4, 0xba, 0xb9, 0x97, 0xb8, 0x0a, 0xd1, 0x1c, 0x28, 0xf7, 0xfb,
0x1f, 0xba, 0xa4, 0xfc, 0x00, 0x9b, 0x49, 0x22, 0xfa, 0x16, 0xe2, 0x2c, 0xcd, 0x01, 0x76, 0xfc,
0x40, 0x96, 0xca, 0xd9, 0xd5, 0xc5, 0xbb, 0xd8, 0xf1, 0x9b, 0xeb, 0xe3, 0x89, 0x9e, 0xd3, 0x2b,
0x47, 0x55, 0x23, 0xce, 0x63, 0xba, 0x1f, 0x28, 0xd6, 0x4c, 0x6c, 0xba, 0x81, 0x1e, 0xc3, 0x46,
0xd8, 0xce, 0xd3, 0xba, 0x87, 0x5d, 0x9c, 0x9b, 0xb6, 0xa2, 0x01, 0xe2, 0xa0, 0x47, 0x6e, 0x18,
0xaa, 0xc0, 0x76, 0x2c, 0x66, 0x09, 0x68, 0x26, 0x01, 0x2d, 0xce, 0x0e, 0xa7, 0x70, 0x85, 0xc0,
0x83, 0x44, 0xfb, 0x05, 0x03, 0xea, 0x05, 0x04, 0x75, 0x61, 0x33, 0x31, 0x63, 0x51, 0x56, 0xef,
0xaf, 0xd8, 0x08, 0x3c, 0xb0, 0x91, 0x8a, 0xa0, 0xfc, 0x26, 0xc1, 0xc3, 0x16, 0x61, 0xa4, 0x1f,
0x0f, 0x4a, 0x34, 0xa5, 0x0a, 0xe4, 0x12, 0xf9, 0x14, 0xc3, 0xd1, 0xca, 0x9f, 0x34, 0xf4, 0x6a,
0xb5, 0x6a, 0xf0, 0x33, 0xf4, 0x29, 0xbc, 0x91, 0x9a, 0x43, 0xf3, 0x85, 0xe3, 0xb1, 0x40, 0xce,
0xf0, 0x71, 0xd8, 0x1e, 0xf3, 0x4e, 0xd6, 0xab, 0xd1, 0x44, 0x3e, 0x70, 0x13, 0xb3, 0x78, 0x31,
0x45, 0xa6, 0x67, 0x24, 0x7b, 0xdb, 0x8c, 0x28, 0x0d, 0x78, 0x34, 0x6f, 0x32, 0xbc, 0x91, 0x77,
0x61, 0x6b, 0xc1, 0x23, 0x62, 0x6c, 0x26, 0xa5, 0x94, 0x06, 0xec, 0x76, 0x9c, 0x20, 0x26, 0x07,
0x51, 0x8a, 0x29, 0x75, 0xe9, 0x56, 0xf5, 0xef, 0xe0, 0xe1, 0x1c, 0x3d, 0x14, 0x6f, 0x41, 0x21,
0xd2, 0x89, 0x6a, 0xf1, 0xde, 0xf2, 0x5a, 0xc4, 0xfe, 0x67, 0xc4, 0xda, 0xbf, 0x59, 0x40, 0xbd,
0x59, 0x4d, 0x9e, 0x89, 0xb7, 0x1c, 0xfd, 0x2c, 0x41, 0x21, 0x2e, 0x1d, 0x52, 0xef, 0xf6, 0x52,
0x95, 0xb4, 0x95, 0xf1, 0x22, 0x17, 0x45, 0x19, 0xff, 0xf5, 0xcf, 0x2f, 0x99, 0x7d, 0x65, 0x6f,
0xf1, 0x93, 0x4e, 0x8e, 0xa5, 0x43, 0xf4, 0xab, 0x04, 0xc5, 0x74, 0x1d, 0x50, 0x7d, 0xb9, 0xce,
0xc2, 0xd6, 0x2a, 0x7d, 0x70, 0x37, 0x52, 0xe8, 0xf0, 0x1d, 0xee, 0xf0, 0x4d, 0x65, 0x37, 0xed,
0xd0, 0xe2, 0xe8, 0xd0, 0xde, 0x56, 0xaa, 0x50, 0xa8, 0xf6, 0x9a, 0x6a, 0x2c, 0x68, 0x8a, 0x52,
0xfd, 0x4e, 0x9c, 0xe5, 0xb7, 0x17, 0x17, 0xf9, 0x58, 0x3a, 0x6c, 0x7a, 0x50, 0x4e, 0x47, 0x1e,
0x38, 0xf3, 0xd1, 0xbf, 0xf9, 0xdc, 0x76, 0xd8, 0x8b, 0xe1, 0x73, 0xb5, 0x4f, 0xaf, 0x35, 0x01,
0xae, 0x88, 0xaf, 0xd6, 0xa6, 0x15, 0x9b, 0x78, 0xfc, 0x53, 0xd5, 0x96, 0xfd, 0xc1, 0x1f, 0xc7,
0x8b, 0xe7, 0x79, 0x8e, 0xae, 0xff, 0x1f, 0x00, 0x00, 0xff, 0xff, 0xd0, 0x54, 0x40, 0xe5, 0x47,
0x08, 0x00, 0x00,
}
// Reference imports to suppress errors if they are not otherwise used.
var _ context.Context
var _ grpc.ClientConnInterface
// This is a compile-time assertion to ensure that this generated file
// is compatible with the grpc package it is being compiled against.
const _ = grpc.SupportPackageIsVersion6
// TranslationServiceClient is the client API for TranslationService service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type TranslationServiceClient interface {
// Translates the text to the specified language.
Translate(ctx context.Context, in *TranslateRequest, opts ...grpc.CallOption) (*TranslateResponse, error)
// Detects the language of the text.
DetectLanguage(ctx context.Context, in *DetectLanguageRequest, opts ...grpc.CallOption) (*DetectLanguageResponse, error)
// Retrieves the list of supported languages.
ListLanguages(ctx context.Context, in *ListLanguagesRequest, opts ...grpc.CallOption) (*ListLanguagesResponse, error)
}
type translationServiceClient struct {
cc grpc.ClientConnInterface
}
func NewTranslationServiceClient(cc grpc.ClientConnInterface) TranslationServiceClient {
return &translationServiceClient{cc}
}
func (c *translationServiceClient) Translate(ctx context.Context, in *TranslateRequest, opts ...grpc.CallOption) (*TranslateResponse, error) {
out := new(TranslateResponse)
err := c.cc.Invoke(ctx, "/yandex.cloud.ai.translate.v2.TranslationService/Translate", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *translationServiceClient) DetectLanguage(ctx context.Context, in *DetectLanguageRequest, opts ...grpc.CallOption) (*DetectLanguageResponse, error) {
out := new(DetectLanguageResponse)
err := c.cc.Invoke(ctx, "/yandex.cloud.ai.translate.v2.TranslationService/DetectLanguage", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *translationServiceClient) ListLanguages(ctx context.Context, in *ListLanguagesRequest, opts ...grpc.CallOption) (*ListLanguagesResponse, error) {
out := new(ListLanguagesResponse)
err := c.cc.Invoke(ctx, "/yandex.cloud.ai.translate.v2.TranslationService/ListLanguages", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
// TranslationServiceServer is the server API for TranslationService service.
type TranslationServiceServer interface {
// Translates the text to the specified language.
Translate(context.Context, *TranslateRequest) (*TranslateResponse, error)
// Detects the language of the text.
DetectLanguage(context.Context, *DetectLanguageRequest) (*DetectLanguageResponse, error)
// Retrieves the list of supported languages.
ListLanguages(context.Context, *ListLanguagesRequest) (*ListLanguagesResponse, error)
}
// UnimplementedTranslationServiceServer can be embedded to have forward compatible implementations.
type UnimplementedTranslationServiceServer struct {
}
func (*UnimplementedTranslationServiceServer) Translate(ctx context.Context, req *TranslateRequest) (*TranslateResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method Translate not implemented")
}
func (*UnimplementedTranslationServiceServer) DetectLanguage(ctx context.Context, req *DetectLanguageRequest) (*DetectLanguageResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method DetectLanguage not implemented")
}
func (*UnimplementedTranslationServiceServer) ListLanguages(ctx context.Context, req *ListLanguagesRequest) (*ListLanguagesResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method ListLanguages not implemented")
}
func RegisterTranslationServiceServer(s *grpc.Server, srv TranslationServiceServer) {
s.RegisterService(&_TranslationService_serviceDesc, srv)
}
func _TranslationService_Translate_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(TranslateRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(TranslationServiceServer).Translate(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/yandex.cloud.ai.translate.v2.TranslationService/Translate",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(TranslationServiceServer).Translate(ctx, req.(*TranslateRequest))
}
return interceptor(ctx, in, info, handler)
}
func _TranslationService_DetectLanguage_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(DetectLanguageRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(TranslationServiceServer).DetectLanguage(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/yandex.cloud.ai.translate.v2.TranslationService/DetectLanguage",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(TranslationServiceServer).DetectLanguage(ctx, req.(*DetectLanguageRequest))
}
return interceptor(ctx, in, info, handler)
}
func _TranslationService_ListLanguages_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(ListLanguagesRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(TranslationServiceServer).ListLanguages(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/yandex.cloud.ai.translate.v2.TranslationService/ListLanguages",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(TranslationServiceServer).ListLanguages(ctx, req.(*ListLanguagesRequest))
}
return interceptor(ctx, in, info, handler)
}
var _TranslationService_serviceDesc = grpc.ServiceDesc{
ServiceName: "yandex.cloud.ai.translate.v2.TranslationService",
HandlerType: (*TranslationServiceServer)(nil),
Methods: []grpc.MethodDesc{
{
MethodName: "Translate",
Handler: _TranslationService_Translate_Handler,
},
{
MethodName: "DetectLanguage",
Handler: _TranslationService_DetectLanguage_Handler,
},
{
MethodName: "ListLanguages",
Handler: _TranslationService_ListLanguages_Handler,
},
},
Streams: []grpc.StreamDesc{},
Metadata: "yandex/cloud/ai/translate/v2/translation_service.proto",
}

83
vendor/github.com/yandex-cloud/go-genproto/yandex/cloud/ai/translate/v2/translation_service.pbext.go generated vendored Normal file
View file

@ -0,0 +1,83 @@
// Code generated by protoc-gen-goext. DO NOT EDIT.
package translate
func (m *TranslateRequest) SetSourceLanguageCode(v string) {
m.SourceLanguageCode = v
}
func (m *TranslateRequest) SetTargetLanguageCode(v string) {
m.TargetLanguageCode = v
}
func (m *TranslateRequest) SetFormat(v TranslateRequest_Format) {
m.Format = v
}
func (m *TranslateRequest) SetTexts(v []string) {
m.Texts = v
}
func (m *TranslateRequest) SetFolderId(v string) {
m.FolderId = v
}
func (m *TranslateRequest) SetModel(v string) {
m.Model = v
}
func (m *TranslateRequest) SetGlossaryConfig(v *TranslateGlossaryConfig) {
m.GlossaryConfig = v
}
type TranslateGlossaryConfig_GlossarySource = isTranslateGlossaryConfig_GlossarySource
func (m *TranslateGlossaryConfig) SetGlossarySource(v TranslateGlossaryConfig_GlossarySource) {
m.GlossarySource = v
}
func (m *TranslateGlossaryConfig) SetGlossaryData(v *GlossaryData) {
m.GlossarySource = &TranslateGlossaryConfig_GlossaryData{
GlossaryData: v,
}
}
func (m *GlossaryData) SetGlossaryPairs(v []*GlossaryPair) {
m.GlossaryPairs = v
}
func (m *GlossaryPair) SetSourceText(v string) {
m.SourceText = v
}
func (m *GlossaryPair) SetTranslatedText(v string) {
m.TranslatedText = v
}
func (m *TranslateResponse) SetTranslations(v []*TranslatedText) {
m.Translations = v
}
func (m *DetectLanguageRequest) SetText(v string) {
m.Text = v
}
func (m *DetectLanguageRequest) SetLanguageCodeHints(v []string) {
m.LanguageCodeHints = v
}
func (m *DetectLanguageRequest) SetFolderId(v string) {
m.FolderId = v
}
func (m *DetectLanguageResponse) SetLanguageCode(v string) {
m.LanguageCode = v
}
func (m *ListLanguagesRequest) SetFolderId(v string) {
m.FolderId = v
}
func (m *ListLanguagesResponse) SetLanguages(v []*Language) {
m.Languages = v
}

141
vendor/github.com/yandex-cloud/go-genproto/yandex/cloud/ai/vision/v1/classification.pb.go generated vendored Normal file
View file

@ -0,0 +1,141 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
// source: yandex/cloud/ai/vision/v1/classification.proto
package vision
import (
fmt "fmt"
proto "github.com/golang/protobuf/proto"
math "math"
)
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf
// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.ProtoPackageIsVersion3 // please upgrade the proto package
type ClassAnnotation struct {
// Properties extracted by a specified model.
//
// For example, if you ask to evaluate the image quality,
// the service could return such properties as `good` and `bad`.
Properties []*Property `protobuf:"bytes,1,rep,name=properties,proto3" json:"properties,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *ClassAnnotation) Reset() { *m = ClassAnnotation{} }
func (m *ClassAnnotation) String() string { return proto.CompactTextString(m) }
func (*ClassAnnotation) ProtoMessage() {}
func (*ClassAnnotation) Descriptor() ([]byte, []int) {
return fileDescriptor_4b6a3b28cb9191ec, []int{0}
}
func (m *ClassAnnotation) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_ClassAnnotation.Unmarshal(m, b)
}
func (m *ClassAnnotation) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_ClassAnnotation.Marshal(b, m, deterministic)
}
func (m *ClassAnnotation) XXX_Merge(src proto.Message) {
xxx_messageInfo_ClassAnnotation.Merge(m, src)
}
func (m *ClassAnnotation) XXX_Size() int {
return xxx_messageInfo_ClassAnnotation.Size(m)
}
func (m *ClassAnnotation) XXX_DiscardUnknown() {
xxx_messageInfo_ClassAnnotation.DiscardUnknown(m)
}
var xxx_messageInfo_ClassAnnotation proto.InternalMessageInfo
func (m *ClassAnnotation) GetProperties() []*Property {
if m != nil {
return m.Properties
}
return nil
}
type Property struct {
// Property name.
Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
// Probability of the property, from 0 to 1.
Probability float64 `protobuf:"fixed64,2,opt,name=probability,proto3" json:"probability,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *Property) Reset() { *m = Property{} }
func (m *Property) String() string { return proto.CompactTextString(m) }
func (*Property) ProtoMessage() {}
func (*Property) Descriptor() ([]byte, []int) {
return fileDescriptor_4b6a3b28cb9191ec, []int{1}
}
func (m *Property) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_Property.Unmarshal(m, b)
}
func (m *Property) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_Property.Marshal(b, m, deterministic)
}
func (m *Property) XXX_Merge(src proto.Message) {
xxx_messageInfo_Property.Merge(m, src)
}
func (m *Property) XXX_Size() int {
return xxx_messageInfo_Property.Size(m)
}
func (m *Property) XXX_DiscardUnknown() {
xxx_messageInfo_Property.DiscardUnknown(m)
}
var xxx_messageInfo_Property proto.InternalMessageInfo
func (m *Property) GetName() string {
if m != nil {
return m.Name
}
return ""
}
func (m *Property) GetProbability() float64 {
if m != nil {
return m.Probability
}
return 0
}
func init() {
proto.RegisterType((*ClassAnnotation)(nil), "yandex.cloud.ai.vision.v1.ClassAnnotation")
proto.RegisterType((*Property)(nil), "yandex.cloud.ai.vision.v1.Property")
}
func init() {
proto.RegisterFile("yandex/cloud/ai/vision/v1/classification.proto", fileDescriptor_4b6a3b28cb9191ec)
}
var fileDescriptor_4b6a3b28cb9191ec = []byte{
// 225 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x74, 0x90, 0x31, 0x4b, 0x04, 0x31,
0x10, 0x85, 0x89, 0x8a, 0xe8, 0x5c, 0x21, 0xa4, 0x5a, 0x0b, 0x61, 0x39, 0x9b, 0x6d, 0x6e, 0xc2,
0x69, 0x69, 0xa3, 0x9e, 0x3f, 0x40, 0xb6, 0xb0, 0xb0, 0x4b, 0x72, 0x71, 0x1d, 0xd8, 0xcb, 0x84,
0x24, 0xb7, 0xb8, 0xff, 0x5e, 0x4c, 0x10, 0xee, 0x8a, 0xeb, 0x1e, 0x8f, 0xef, 0xcd, 0x63, 0x1e,
0xe0, 0xac, 0xfd, 0xd6, 0xfd, 0x28, 0x3b, 0xf2, 0x7e, 0xab, 0x34, 0xa9, 0x89, 0x12, 0xb1, 0x57,
0xd3, 0x5a, 0xd9, 0x51, 0xa7, 0x44, 0x5f, 0x64, 0x75, 0x26, 0xf6, 0x18, 0x22, 0x67, 0x96, 0xb7,
0x95, 0xc7, 0xc2, 0xa3, 0x26, 0xac, 0x3c, 0x4e, 0xeb, 0xe5, 0x07, 0xdc, 0x6c, 0xfe, 0x22, 0x2f,
0xde, 0x73, 0x2e, 0x19, 0xb9, 0x01, 0x08, 0x91, 0x83, 0x8b, 0x99, 0x5c, 0x6a, 0x44, 0x7b, 0xde,
0x2d, 0x1e, 0xee, 0xf1, 0xe4, 0x09, 0x7c, 0xaf, 0xf0, 0xdc, 0x1f, 0xc4, 0x96, 0xcf, 0x70, 0xf5,
0xef, 0x4b, 0x09, 0x17, 0x5e, 0xef, 0x5c, 0x23, 0x5a, 0xd1, 0x5d, 0xf7, 0x45, 0xcb, 0x16, 0x16,
0x21, 0xb2, 0xd1, 0x86, 0x46, 0xca, 0x73, 0x73, 0xd6, 0x8a, 0x4e, 0xf4, 0x87, 0xd6, 0xab, 0x83,
0xbb, 0xe3, 0xce, 0x40, 0x47, 0xbd, 0x9f, 0x6f, 0x03, 0xe5, 0xef, 0xbd, 0x41, 0xcb, 0x3b, 0x55,
0xc9, 0x55, 0x1d, 0x64, 0xe0, 0xd5, 0xe0, 0x7c, 0x79, 0x5d, 0x9d, 0x5c, 0xea, 0xa9, 0x2a, 0x73,
0x59, 0xb8, 0xc7, 0xdf, 0x00, 0x00, 0x00, 0xff, 0xff, 0xde, 0xdf, 0xa0, 0x72, 0x54, 0x01, 0x00,
0x00,
}

15
vendor/github.com/yandex-cloud/go-genproto/yandex/cloud/ai/vision/v1/classification.pbext.go generated vendored Normal file
View file

@ -0,0 +1,15 @@
// Code generated by protoc-gen-goext. DO NOT EDIT.
package vision
func (m *ClassAnnotation) SetProperties(v []*Property) {
m.Properties = v
}
func (m *Property) SetName(v string) {
m.Name = v
}
func (m *Property) SetProbability(v float64) {
m.Probability = v
}

129
vendor/github.com/yandex-cloud/go-genproto/yandex/cloud/ai/vision/v1/face_detection.pb.go generated vendored Normal file
View file

@ -0,0 +1,129 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
// source: yandex/cloud/ai/vision/v1/face_detection.proto
package vision
import (
fmt "fmt"
proto "github.com/golang/protobuf/proto"
math "math"
)
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf
// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.ProtoPackageIsVersion3 // please upgrade the proto package
type FaceAnnotation struct {
// An array of detected faces for the specified image.
Faces []*Face `protobuf:"bytes,1,rep,name=faces,proto3" json:"faces,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *FaceAnnotation) Reset() { *m = FaceAnnotation{} }
func (m *FaceAnnotation) String() string { return proto.CompactTextString(m) }
func (*FaceAnnotation) ProtoMessage() {}
func (*FaceAnnotation) Descriptor() ([]byte, []int) {
return fileDescriptor_88a95cd8b6371094, []int{0}
}
func (m *FaceAnnotation) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_FaceAnnotation.Unmarshal(m, b)
}
func (m *FaceAnnotation) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_FaceAnnotation.Marshal(b, m, deterministic)
}
func (m *FaceAnnotation) XXX_Merge(src proto.Message) {
xxx_messageInfo_FaceAnnotation.Merge(m, src)
}
func (m *FaceAnnotation) XXX_Size() int {
return xxx_messageInfo_FaceAnnotation.Size(m)
}
func (m *FaceAnnotation) XXX_DiscardUnknown() {
xxx_messageInfo_FaceAnnotation.DiscardUnknown(m)
}
var xxx_messageInfo_FaceAnnotation proto.InternalMessageInfo
func (m *FaceAnnotation) GetFaces() []*Face {
if m != nil {
return m.Faces
}
return nil
}
type Face struct {
// Area on the image where the face is located.
BoundingBox *Polygon `protobuf:"bytes,1,opt,name=bounding_box,json=boundingBox,proto3" json:"bounding_box,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *Face) Reset() { *m = Face{} }
func (m *Face) String() string { return proto.CompactTextString(m) }
func (*Face) ProtoMessage() {}
func (*Face) Descriptor() ([]byte, []int) {
return fileDescriptor_88a95cd8b6371094, []int{1}
}
func (m *Face) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_Face.Unmarshal(m, b)
}
func (m *Face) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_Face.Marshal(b, m, deterministic)
}
func (m *Face) XXX_Merge(src proto.Message) {
xxx_messageInfo_Face.Merge(m, src)
}
func (m *Face) XXX_Size() int {
return xxx_messageInfo_Face.Size(m)
}
func (m *Face) XXX_DiscardUnknown() {
xxx_messageInfo_Face.DiscardUnknown(m)
}
var xxx_messageInfo_Face proto.InternalMessageInfo
func (m *Face) GetBoundingBox() *Polygon {
if m != nil {
return m.BoundingBox
}
return nil
}
func init() {
proto.RegisterType((*FaceAnnotation)(nil), "yandex.cloud.ai.vision.v1.FaceAnnotation")
proto.RegisterType((*Face)(nil), "yandex.cloud.ai.vision.v1.Face")
}
func init() {
proto.RegisterFile("yandex/cloud/ai/vision/v1/face_detection.proto", fileDescriptor_88a95cd8b6371094)
}
var fileDescriptor_88a95cd8b6371094 = []byte{
// 234 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x7c, 0x90, 0x3d, 0x6b, 0xc3, 0x30,
0x10, 0x40, 0x31, 0xfd, 0x18, 0xe4, 0xd2, 0xc1, 0x53, 0x5a, 0x28, 0x0d, 0x9e, 0x42, 0x21, 0x27,
0x92, 0xd2, 0xa9, 0x53, 0x43, 0x3f, 0xa6, 0x42, 0xc9, 0xd8, 0x25, 0xc8, 0xf2, 0x55, 0x3d, 0x48,
0xee, 0x4c, 0x2c, 0x0b, 0xe7, 0xdf, 0x17, 0x59, 0x74, 0xc8, 0xe0, 0x6c, 0x12, 0xbc, 0xf7, 0x8e,
0x3b, 0x05, 0x07, 0xc3, 0x35, 0xf6, 0xda, 0x6e, 0xa5, 0xab, 0xb5, 0x21, 0x1d, 0xa8, 0x25, 0x61,
0x1d, 0x16, 0xfa, 0xc7, 0x58, 0xdc, 0xd4, 0xe8, 0xd1, 0x7a, 0x12, 0x86, 0x66, 0x2f, 0x5e, 0x8a,
0x9b, 0xc4, 0xc3, 0xc0, 0x83, 0x21, 0x48, 0x3c, 0x84, 0xc5, 0xed, 0xc3, 0x78, 0xaa, 0xd9, 0xd3,
0x8e, 0x3c, 0x05, 0x6c, 0x53, 0xa6, 0xfc, 0x50, 0xd7, 0xef, 0xc6, 0xe2, 0x0b, 0xb3, 0x78, 0x13,
0xf3, 0xc5, 0x93, 0xba, 0x88, 0x03, 0xdb, 0x49, 0x36, 0x3d, 0x9b, 0xe5, 0xcb, 0x7b, 0x18, 0x1d,
0x04, 0xd1, 0x5c, 0x27, 0xba, 0xfc, 0x54, 0xe7, 0xf1, 0x5b, 0xbc, 0xa9, 0xab, 0x4a, 0x3a, 0xae,
0x89, 0xdd, 0xa6, 0x92, 0x7e, 0x92, 0x4d, 0xb3, 0x59, 0xbe, 0x2c, 0x4f, 0x54, 0xbe, 0x64, 0x7b,
0x70, 0xc2, 0xeb, 0xfc, 0xdf, 0x5b, 0x49, 0xbf, 0x42, 0x75, 0x77, 0x6c, 0x34, 0x74, 0x64, 0x7d,
0xbf, 0x3a, 0xf2, 0xbf, 0x5d, 0x05, 0x56, 0x76, 0x3a, 0x91, 0xf3, 0xb4, 0xaf, 0x93, 0xb9, 0x43,
0x1e, 0xb6, 0xd3, 0xa3, 0x87, 0x78, 0x4e, 0xaf, 0xea, 0x72, 0xe0, 0x1e, 0xff, 0x02, 0x00, 0x00,
0xff, 0xff, 0xf7, 0xd2, 0x42, 0xad, 0x7e, 0x01, 0x00, 0x00,
}

11
vendor/github.com/yandex-cloud/go-genproto/yandex/cloud/ai/vision/v1/face_detection.pbext.go generated vendored Normal file
View file

@ -0,0 +1,11 @@
// Code generated by protoc-gen-goext. DO NOT EDIT.
package vision
func (m *FaceAnnotation) SetFaces(v []*Face) {
m.Faces = v
}
func (m *Face) SetBoundingBox(v *Polygon) {
m.BoundingBox = v
}

168
vendor/github.com/yandex-cloud/go-genproto/yandex/cloud/ai/vision/v1/image_copy_search.pb.go generated vendored Normal file
View file

@ -0,0 +1,168 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
// source: yandex/cloud/ai/vision/v1/image_copy_search.proto
package vision
import (
fmt "fmt"
proto "github.com/golang/protobuf/proto"
math "math"
)
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf
// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.ProtoPackageIsVersion3 // please upgrade the proto package
type ImageCopySearchAnnotation struct {
// Number of image copies
CopyCount int64 `protobuf:"varint,1,opt,name=copy_count,json=copyCount,proto3" json:"copy_count,omitempty"`
// Top relevance result of image copy search
TopResults []*CopyMatch `protobuf:"bytes,2,rep,name=top_results,json=topResults,proto3" json:"top_results,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *ImageCopySearchAnnotation) Reset() { *m = ImageCopySearchAnnotation{} }
func (m *ImageCopySearchAnnotation) String() string { return proto.CompactTextString(m) }
func (*ImageCopySearchAnnotation) ProtoMessage() {}
func (*ImageCopySearchAnnotation) Descriptor() ([]byte, []int) {
return fileDescriptor_6781c0cf9dfefbb7, []int{0}
}
func (m *ImageCopySearchAnnotation) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_ImageCopySearchAnnotation.Unmarshal(m, b)
}
func (m *ImageCopySearchAnnotation) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_ImageCopySearchAnnotation.Marshal(b, m, deterministic)
}
func (m *ImageCopySearchAnnotation) XXX_Merge(src proto.Message) {
xxx_messageInfo_ImageCopySearchAnnotation.Merge(m, src)
}
func (m *ImageCopySearchAnnotation) XXX_Size() int {
return xxx_messageInfo_ImageCopySearchAnnotation.Size(m)
}
func (m *ImageCopySearchAnnotation) XXX_DiscardUnknown() {
xxx_messageInfo_ImageCopySearchAnnotation.DiscardUnknown(m)
}
var xxx_messageInfo_ImageCopySearchAnnotation proto.InternalMessageInfo
func (m *ImageCopySearchAnnotation) GetCopyCount() int64 {
if m != nil {
return m.CopyCount
}
return 0
}
func (m *ImageCopySearchAnnotation) GetTopResults() []*CopyMatch {
if m != nil {
return m.TopResults
}
return nil
}
type CopyMatch struct {
//url of image
ImageUrl string `protobuf:"bytes,1,opt,name=image_url,json=imageUrl,proto3" json:"image_url,omitempty"`
//url of page that contains image
PageUrl string `protobuf:"bytes,2,opt,name=page_url,json=pageUrl,proto3" json:"page_url,omitempty"`
//page title that contains image
Title string `protobuf:"bytes,3,opt,name=title,proto3" json:"title,omitempty"`
//image description
Description string `protobuf:"bytes,4,opt,name=description,proto3" json:"description,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *CopyMatch) Reset() { *m = CopyMatch{} }
func (m *CopyMatch) String() string { return proto.CompactTextString(m) }
func (*CopyMatch) ProtoMessage() {}
func (*CopyMatch) Descriptor() ([]byte, []int) {
return fileDescriptor_6781c0cf9dfefbb7, []int{1}
}
func (m *CopyMatch) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_CopyMatch.Unmarshal(m, b)
}
func (m *CopyMatch) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_CopyMatch.Marshal(b, m, deterministic)
}
func (m *CopyMatch) XXX_Merge(src proto.Message) {
xxx_messageInfo_CopyMatch.Merge(m, src)
}
func (m *CopyMatch) XXX_Size() int {
return xxx_messageInfo_CopyMatch.Size(m)
}
func (m *CopyMatch) XXX_DiscardUnknown() {
xxx_messageInfo_CopyMatch.DiscardUnknown(m)
}
var xxx_messageInfo_CopyMatch proto.InternalMessageInfo
func (m *CopyMatch) GetImageUrl() string {
if m != nil {
return m.ImageUrl
}
return ""
}
func (m *CopyMatch) GetPageUrl() string {
if m != nil {
return m.PageUrl
}
return ""
}
func (m *CopyMatch) GetTitle() string {
if m != nil {
return m.Title
}
return ""
}
func (m *CopyMatch) GetDescription() string {
if m != nil {
return m.Description
}
return ""
}
func init() {
proto.RegisterType((*ImageCopySearchAnnotation)(nil), "yandex.cloud.ai.vision.v1.ImageCopySearchAnnotation")
proto.RegisterType((*CopyMatch)(nil), "yandex.cloud.ai.vision.v1.CopyMatch")
}
func init() {
proto.RegisterFile("yandex/cloud/ai/vision/v1/image_copy_search.proto", fileDescriptor_6781c0cf9dfefbb7)
}
var fileDescriptor_6781c0cf9dfefbb7 = []byte{
// 288 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x74, 0x91, 0xb1, 0x4f, 0xf3, 0x30,
0x10, 0xc5, 0xd5, 0xf6, 0xfb, 0xa0, 0xb9, 0x6c, 0x16, 0x43, 0x22, 0x54, 0x29, 0xaa, 0x18, 0xba,
0xd4, 0x56, 0x60, 0x64, 0x82, 0xc2, 0xc0, 0xc0, 0x12, 0xc4, 0xc2, 0x12, 0xb9, 0x8e, 0x95, 0x58,
0x4a, 0x7d, 0x96, 0xe3, 0x44, 0x44, 0x4c, 0xfc, 0xe7, 0x28, 0x36, 0x20, 0x3a, 0x74, 0xb3, 0xdf,
0xbb, 0x9f, 0xdf, 0xdd, 0x19, 0xf2, 0x91, 0xeb, 0x4a, 0xbe, 0x33, 0xd1, 0x62, 0x5f, 0x31, 0xae,
0xd8, 0xa0, 0x3a, 0x85, 0x9a, 0x0d, 0x39, 0x53, 0x07, 0x5e, 0xcb, 0x52, 0xa0, 0x19, 0xcb, 0x4e,
0x72, 0x2b, 0x1a, 0x6a, 0x2c, 0x3a, 0x24, 0x69, 0x40, 0xa8, 0x47, 0x28, 0x57, 0x34, 0x20, 0x74,
0xc8, 0xd7, 0x9f, 0x33, 0x48, 0x9f, 0x26, 0x6c, 0x87, 0x66, 0x7c, 0xf1, 0xd0, 0x9d, 0xd6, 0xe8,
0xb8, 0x53, 0xa8, 0xc9, 0x0a, 0xc0, 0xbf, 0x26, 0xb0, 0xd7, 0x2e, 0x99, 0x65, 0xb3, 0xcd, 0xa2,
0x88, 0x26, 0x65, 0x37, 0x09, 0xe4, 0x11, 0x62, 0x87, 0xa6, 0xb4, 0xb2, 0xeb, 0x5b, 0xd7, 0x25,
0xf3, 0x6c, 0xb1, 0x89, 0xaf, 0xaf, 0xe8, 0xc9, 0x34, 0x3a, 0x85, 0x3c, 0x73, 0x27, 0x9a, 0x02,
0x1c, 0x9a, 0x22, 0x70, 0xeb, 0x0f, 0x88, 0x7e, 0x0d, 0x72, 0x09, 0x51, 0x18, 0xa3, 0xb7, 0xad,
0x4f, 0x8c, 0x8a, 0xa5, 0x17, 0x5e, 0x6d, 0x4b, 0x52, 0x58, 0x9a, 0x1f, 0x6f, 0xee, 0xbd, 0x73,
0xf3, 0x6d, 0x5d, 0xc0, 0x7f, 0xa7, 0x5c, 0x2b, 0x93, 0x85, 0xd7, 0xc3, 0x85, 0x64, 0x10, 0x57,
0xb2, 0x13, 0x56, 0x99, 0x69, 0x9e, 0xe4, 0x9f, 0xf7, 0xfe, 0x4a, 0xf7, 0x12, 0x56, 0xc7, 0xfd,
0x1a, 0x75, 0xd4, 0xf3, 0xdb, 0x43, 0xad, 0x5c, 0xd3, 0xef, 0xa9, 0xc0, 0x03, 0x0b, 0x95, 0xdb,
0xb0, 0xfa, 0x1a, 0xb7, 0xb5, 0xd4, 0x7e, 0xc3, 0xec, 0xe4, 0x9f, 0xdc, 0x86, 0xd3, 0xfe, 0xcc,
0xd7, 0xdd, 0x7c, 0x05, 0x00, 0x00, 0xff, 0xff, 0xe3, 0xf6, 0xdf, 0xb9, 0xbe, 0x01, 0x00, 0x00,
}

27
vendor/github.com/yandex-cloud/go-genproto/yandex/cloud/ai/vision/v1/image_copy_search.pbext.go generated vendored Normal file
View file

@ -0,0 +1,27 @@
// Code generated by protoc-gen-goext. DO NOT EDIT.
package vision
func (m *ImageCopySearchAnnotation) SetCopyCount(v int64) {
m.CopyCount = v
}
func (m *ImageCopySearchAnnotation) SetTopResults(v []*CopyMatch) {
m.TopResults = v
}
func (m *CopyMatch) SetImageUrl(v string) {
m.ImageUrl = v
}
func (m *CopyMatch) SetPageUrl(v string) {
m.PageUrl = v
}
func (m *CopyMatch) SetTitle(v string) {
m.Title = v
}
func (m *CopyMatch) SetDescription(v string) {
m.Description = v
}

136
vendor/github.com/yandex-cloud/go-genproto/yandex/cloud/ai/vision/v1/primitives.pb.go generated vendored Normal file
View file

@ -0,0 +1,136 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
// source: yandex/cloud/ai/vision/v1/primitives.proto
package vision
import (
fmt "fmt"
proto "github.com/golang/protobuf/proto"
math "math"
)
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf
// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.ProtoPackageIsVersion3 // please upgrade the proto package
type Polygon struct {
// The bounding polygon vertices.
Vertices []*Vertex `protobuf:"bytes,1,rep,name=vertices,proto3" json:"vertices,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *Polygon) Reset() { *m = Polygon{} }
func (m *Polygon) String() string { return proto.CompactTextString(m) }
func (*Polygon) ProtoMessage() {}
func (*Polygon) Descriptor() ([]byte, []int) {
return fileDescriptor_9f9f7b59bd69f434, []int{0}
}
func (m *Polygon) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_Polygon.Unmarshal(m, b)
}
func (m *Polygon) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_Polygon.Marshal(b, m, deterministic)
}
func (m *Polygon) XXX_Merge(src proto.Message) {
xxx_messageInfo_Polygon.Merge(m, src)
}
func (m *Polygon) XXX_Size() int {
return xxx_messageInfo_Polygon.Size(m)
}
func (m *Polygon) XXX_DiscardUnknown() {
xxx_messageInfo_Polygon.DiscardUnknown(m)
}
var xxx_messageInfo_Polygon proto.InternalMessageInfo
func (m *Polygon) GetVertices() []*Vertex {
if m != nil {
return m.Vertices
}
return nil
}
type Vertex struct {
// X coordinate in pixels.
X int64 `protobuf:"varint,1,opt,name=x,proto3" json:"x,omitempty"`
// Y coordinate in pixels.
Y int64 `protobuf:"varint,2,opt,name=y,proto3" json:"y,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *Vertex) Reset() { *m = Vertex{} }
func (m *Vertex) String() string { return proto.CompactTextString(m) }
func (*Vertex) ProtoMessage() {}
func (*Vertex) Descriptor() ([]byte, []int) {
return fileDescriptor_9f9f7b59bd69f434, []int{1}
}
func (m *Vertex) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_Vertex.Unmarshal(m, b)
}
func (m *Vertex) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_Vertex.Marshal(b, m, deterministic)
}
func (m *Vertex) XXX_Merge(src proto.Message) {
xxx_messageInfo_Vertex.Merge(m, src)
}
func (m *Vertex) XXX_Size() int {
return xxx_messageInfo_Vertex.Size(m)
}
func (m *Vertex) XXX_DiscardUnknown() {
xxx_messageInfo_Vertex.DiscardUnknown(m)
}
var xxx_messageInfo_Vertex proto.InternalMessageInfo
func (m *Vertex) GetX() int64 {
if m != nil {
return m.X
}
return 0
}
func (m *Vertex) GetY() int64 {
if m != nil {
return m.Y
}
return 0
}
func init() {
proto.RegisterType((*Polygon)(nil), "yandex.cloud.ai.vision.v1.Polygon")
proto.RegisterType((*Vertex)(nil), "yandex.cloud.ai.vision.v1.Vertex")
}
func init() {
proto.RegisterFile("yandex/cloud/ai/vision/v1/primitives.proto", fileDescriptor_9f9f7b59bd69f434)
}
var fileDescriptor_9f9f7b59bd69f434 = []byte{
// 203 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0xd2, 0xaa, 0x4c, 0xcc, 0x4b,
0x49, 0xad, 0xd0, 0x4f, 0xce, 0xc9, 0x2f, 0x4d, 0xd1, 0x4f, 0xcc, 0xd4, 0x2f, 0xcb, 0x2c, 0xce,
0xcc, 0xcf, 0xd3, 0x2f, 0x33, 0xd4, 0x2f, 0x28, 0xca, 0xcc, 0xcd, 0x2c, 0xc9, 0x2c, 0x4b, 0x2d,
0xd6, 0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17, 0x92, 0x84, 0xa8, 0xd5, 0x03, 0xab, 0xd5, 0x4b, 0xcc,
0xd4, 0x83, 0xa8, 0xd5, 0x2b, 0x33, 0x54, 0xf2, 0xe0, 0x62, 0x0f, 0xc8, 0xcf, 0xa9, 0x4c, 0xcf,
0xcf, 0x13, 0xb2, 0xe5, 0xe2, 0x28, 0x4b, 0x2d, 0x2a, 0xc9, 0x4c, 0x4e, 0x2d, 0x96, 0x60, 0x54,
0x60, 0xd6, 0xe0, 0x36, 0x52, 0xd4, 0xc3, 0xa9, 0x51, 0x2f, 0x2c, 0xb5, 0xa8, 0x24, 0xb5, 0x22,
0x08, 0xae, 0x45, 0x49, 0x85, 0x8b, 0x0d, 0x22, 0x26, 0xc4, 0xc3, 0xc5, 0x58, 0x21, 0xc1, 0xa8,
0xc0, 0xa8, 0xc1, 0x1c, 0xc4, 0x08, 0xe6, 0x55, 0x4a, 0x30, 0x41, 0x78, 0x95, 0x4e, 0xa9, 0x5c,
0xb2, 0xa8, 0x66, 0x16, 0x64, 0xa2, 0x98, 0x1b, 0xe5, 0x92, 0x9e, 0x59, 0x92, 0x51, 0x9a, 0xa4,
0x97, 0x9c, 0x9f, 0xab, 0x0f, 0x51, 0xa9, 0x0b, 0xf1, 0x62, 0x7a, 0xbe, 0x6e, 0x7a, 0x6a, 0x1e,
0xd8, 0x43, 0xfa, 0x38, 0xfd, 0x6e, 0x0d, 0x61, 0x25, 0xb1, 0x81, 0xd5, 0x19, 0x03, 0x02, 0x00,
0x00, 0xff, 0xff, 0x4e, 0xdd, 0xc9, 0x53, 0x26, 0x01, 0x00, 0x00,
}

15
vendor/github.com/yandex-cloud/go-genproto/yandex/cloud/ai/vision/v1/primitives.pbext.go generated vendored Normal file
View file

@ -0,0 +1,15 @@
// Code generated by protoc-gen-goext. DO NOT EDIT.
package vision
func (m *Polygon) SetVertices(v []*Vertex) {
m.Vertices = v
}
func (m *Vertex) SetX(v int64) {
m.X = v
}
func (m *Vertex) SetY(v int64) {
m.Y = v
}

460
vendor/github.com/yandex-cloud/go-genproto/yandex/cloud/ai/vision/v1/text_detection.pb.go generated vendored Normal file
View file

@ -0,0 +1,460 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
// source: yandex/cloud/ai/vision/v1/text_detection.proto
package vision
import (
fmt "fmt"
proto "github.com/golang/protobuf/proto"
math "math"
)
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf
// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.ProtoPackageIsVersion3 // please upgrade the proto package
type TextAnnotation struct {
// Pages of the recognized file.
//
// For JPEG and PNG files contains only 1 page.
Pages []*Page `protobuf:"bytes,1,rep,name=pages,proto3" json:"pages,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *TextAnnotation) Reset() { *m = TextAnnotation{} }
func (m *TextAnnotation) String() string { return proto.CompactTextString(m) }
func (*TextAnnotation) ProtoMessage() {}
func (*TextAnnotation) Descriptor() ([]byte, []int) {
return fileDescriptor_a4d5be2606a8f8f0, []int{0}
}
func (m *TextAnnotation) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_TextAnnotation.Unmarshal(m, b)
}
func (m *TextAnnotation) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_TextAnnotation.Marshal(b, m, deterministic)
}
func (m *TextAnnotation) XXX_Merge(src proto.Message) {
xxx_messageInfo_TextAnnotation.Merge(m, src)
}
func (m *TextAnnotation) XXX_Size() int {
return xxx_messageInfo_TextAnnotation.Size(m)
}
func (m *TextAnnotation) XXX_DiscardUnknown() {
xxx_messageInfo_TextAnnotation.DiscardUnknown(m)
}
var xxx_messageInfo_TextAnnotation proto.InternalMessageInfo
func (m *TextAnnotation) GetPages() []*Page {
if m != nil {
return m.Pages
}
return nil
}
type Page struct {
// Page width in pixels.
Width int64 `protobuf:"varint,1,opt,name=width,proto3" json:"width,omitempty"`
// Page height in pixels.
Height int64 `protobuf:"varint,2,opt,name=height,proto3" json:"height,omitempty"`
// Recognized text blocks in this page.
Blocks []*Block `protobuf:"bytes,3,rep,name=blocks,proto3" json:"blocks,omitempty"`
// Recognized entities
Entities []*Entity `protobuf:"bytes,4,rep,name=entities,proto3" json:"entities,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *Page) Reset() { *m = Page{} }
func (m *Page) String() string { return proto.CompactTextString(m) }
func (*Page) ProtoMessage() {}
func (*Page) Descriptor() ([]byte, []int) {
return fileDescriptor_a4d5be2606a8f8f0, []int{1}
}
func (m *Page) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_Page.Unmarshal(m, b)
}
func (m *Page) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_Page.Marshal(b, m, deterministic)
}
func (m *Page) XXX_Merge(src proto.Message) {
xxx_messageInfo_Page.Merge(m, src)
}
func (m *Page) XXX_Size() int {
return xxx_messageInfo_Page.Size(m)
}
func (m *Page) XXX_DiscardUnknown() {
xxx_messageInfo_Page.DiscardUnknown(m)
}
var xxx_messageInfo_Page proto.InternalMessageInfo
func (m *Page) GetWidth() int64 {
if m != nil {
return m.Width
}
return 0
}
func (m *Page) GetHeight() int64 {
if m != nil {
return m.Height
}
return 0
}
func (m *Page) GetBlocks() []*Block {
if m != nil {
return m.Blocks
}
return nil
}
func (m *Page) GetEntities() []*Entity {
if m != nil {
return m.Entities
}
return nil
}
type Entity struct {
// Entity name
Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
// Recognized entity text
Text string `protobuf:"bytes,2,opt,name=text,proto3" json:"text,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *Entity) Reset() { *m = Entity{} }
func (m *Entity) String() string { return proto.CompactTextString(m) }
func (*Entity) ProtoMessage() {}
func (*Entity) Descriptor() ([]byte, []int) {
return fileDescriptor_a4d5be2606a8f8f0, []int{2}
}
func (m *Entity) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_Entity.Unmarshal(m, b)
}
func (m *Entity) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_Entity.Marshal(b, m, deterministic)
}
func (m *Entity) XXX_Merge(src proto.Message) {
xxx_messageInfo_Entity.Merge(m, src)
}
func (m *Entity) XXX_Size() int {
return xxx_messageInfo_Entity.Size(m)
}
func (m *Entity) XXX_DiscardUnknown() {
xxx_messageInfo_Entity.DiscardUnknown(m)
}
var xxx_messageInfo_Entity proto.InternalMessageInfo
func (m *Entity) GetName() string {
if m != nil {
return m.Name
}
return ""
}
func (m *Entity) GetText() string {
if m != nil {
return m.Text
}
return ""
}
type Block struct {
// Area on the page where the text block is located.
BoundingBox *Polygon `protobuf:"bytes,1,opt,name=bounding_box,json=boundingBox,proto3" json:"bounding_box,omitempty"`
// Recognized lines in this block.
Lines []*Line `protobuf:"bytes,2,rep,name=lines,proto3" json:"lines,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *Block) Reset() { *m = Block{} }
func (m *Block) String() string { return proto.CompactTextString(m) }
func (*Block) ProtoMessage() {}
func (*Block) Descriptor() ([]byte, []int) {
return fileDescriptor_a4d5be2606a8f8f0, []int{3}
}
func (m *Block) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_Block.Unmarshal(m, b)
}
func (m *Block) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_Block.Marshal(b, m, deterministic)
}
func (m *Block) XXX_Merge(src proto.Message) {
xxx_messageInfo_Block.Merge(m, src)
}
func (m *Block) XXX_Size() int {
return xxx_messageInfo_Block.Size(m)
}
func (m *Block) XXX_DiscardUnknown() {
xxx_messageInfo_Block.DiscardUnknown(m)
}
var xxx_messageInfo_Block proto.InternalMessageInfo
func (m *Block) GetBoundingBox() *Polygon {
if m != nil {
return m.BoundingBox
}
return nil
}
func (m *Block) GetLines() []*Line {
if m != nil {
return m.Lines
}
return nil
}
type Line struct {
// Area on the page where the line is located.
BoundingBox *Polygon `protobuf:"bytes,1,opt,name=bounding_box,json=boundingBox,proto3" json:"bounding_box,omitempty"`
// Recognized words in this line.
Words []*Word `protobuf:"bytes,2,rep,name=words,proto3" json:"words,omitempty"`
// Confidence of the OCR results for the line. Range [0, 1].
Confidence float64 `protobuf:"fixed64,3,opt,name=confidence,proto3" json:"confidence,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *Line) Reset() { *m = Line{} }
func (m *Line) String() string { return proto.CompactTextString(m) }
func (*Line) ProtoMessage() {}
func (*Line) Descriptor() ([]byte, []int) {
return fileDescriptor_a4d5be2606a8f8f0, []int{4}
}
func (m *Line) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_Line.Unmarshal(m, b)
}
func (m *Line) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_Line.Marshal(b, m, deterministic)
}
func (m *Line) XXX_Merge(src proto.Message) {
xxx_messageInfo_Line.Merge(m, src)
}
func (m *Line) XXX_Size() int {
return xxx_messageInfo_Line.Size(m)
}
func (m *Line) XXX_DiscardUnknown() {
xxx_messageInfo_Line.DiscardUnknown(m)
}
var xxx_messageInfo_Line proto.InternalMessageInfo
func (m *Line) GetBoundingBox() *Polygon {
if m != nil {
return m.BoundingBox
}
return nil
}
func (m *Line) GetWords() []*Word {
if m != nil {
return m.Words
}
return nil
}
func (m *Line) GetConfidence() float64 {
if m != nil {
return m.Confidence
}
return 0
}
type Word struct {
// Area on the page where the word is located.
BoundingBox *Polygon `protobuf:"bytes,1,opt,name=bounding_box,json=boundingBox,proto3" json:"bounding_box,omitempty"`
// Recognized word value.
Text string `protobuf:"bytes,2,opt,name=text,proto3" json:"text,omitempty"`
// Confidence of the OCR results for the word. Range [0, 1].
Confidence float64 `protobuf:"fixed64,3,opt,name=confidence,proto3" json:"confidence,omitempty"`
// A list of detected languages together with confidence.
Languages []*Word_DetectedLanguage `protobuf:"bytes,4,rep,name=languages,proto3" json:"languages,omitempty"`
// Id of recognized word in entities array
EntityIndex int64 `protobuf:"varint,5,opt,name=entity_index,json=entityIndex,proto3" json:"entity_index,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *Word) Reset() { *m = Word{} }
func (m *Word) String() string { return proto.CompactTextString(m) }
func (*Word) ProtoMessage() {}
func (*Word) Descriptor() ([]byte, []int) {
return fileDescriptor_a4d5be2606a8f8f0, []int{5}
}
func (m *Word) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_Word.Unmarshal(m, b)
}
func (m *Word) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_Word.Marshal(b, m, deterministic)
}
func (m *Word) XXX_Merge(src proto.Message) {
xxx_messageInfo_Word.Merge(m, src)
}
func (m *Word) XXX_Size() int {
return xxx_messageInfo_Word.Size(m)
}
func (m *Word) XXX_DiscardUnknown() {
xxx_messageInfo_Word.DiscardUnknown(m)
}
var xxx_messageInfo_Word proto.InternalMessageInfo
func (m *Word) GetBoundingBox() *Polygon {
if m != nil {
return m.BoundingBox
}
return nil
}
func (m *Word) GetText() string {
if m != nil {
return m.Text
}
return ""
}
func (m *Word) GetConfidence() float64 {
if m != nil {
return m.Confidence
}
return 0
}
func (m *Word) GetLanguages() []*Word_DetectedLanguage {
if m != nil {
return m.Languages
}
return nil
}
func (m *Word) GetEntityIndex() int64 {
if m != nil {
return m.EntityIndex
}
return 0
}
type Word_DetectedLanguage struct {
// Detected language code.
LanguageCode string `protobuf:"bytes,1,opt,name=language_code,json=languageCode,proto3" json:"language_code,omitempty"`
// Confidence of detected language. Range [0, 1].
Confidence float64 `protobuf:"fixed64,2,opt,name=confidence,proto3" json:"confidence,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *Word_DetectedLanguage) Reset() { *m = Word_DetectedLanguage{} }
func (m *Word_DetectedLanguage) String() string { return proto.CompactTextString(m) }
func (*Word_DetectedLanguage) ProtoMessage() {}
func (*Word_DetectedLanguage) Descriptor() ([]byte, []int) {
return fileDescriptor_a4d5be2606a8f8f0, []int{5, 0}
}
func (m *Word_DetectedLanguage) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_Word_DetectedLanguage.Unmarshal(m, b)
}
func (m *Word_DetectedLanguage) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_Word_DetectedLanguage.Marshal(b, m, deterministic)
}
func (m *Word_DetectedLanguage) XXX_Merge(src proto.Message) {
xxx_messageInfo_Word_DetectedLanguage.Merge(m, src)
}
func (m *Word_DetectedLanguage) XXX_Size() int {
return xxx_messageInfo_Word_DetectedLanguage.Size(m)
}
func (m *Word_DetectedLanguage) XXX_DiscardUnknown() {
xxx_messageInfo_Word_DetectedLanguage.DiscardUnknown(m)
}
var xxx_messageInfo_Word_DetectedLanguage proto.InternalMessageInfo
func (m *Word_DetectedLanguage) GetLanguageCode() string {
if m != nil {
return m.LanguageCode
}
return ""
}
func (m *Word_DetectedLanguage) GetConfidence() float64 {
if m != nil {
return m.Confidence
}
return 0
}
func init() {
proto.RegisterType((*TextAnnotation)(nil), "yandex.cloud.ai.vision.v1.TextAnnotation")
proto.RegisterType((*Page)(nil), "yandex.cloud.ai.vision.v1.Page")
proto.RegisterType((*Entity)(nil), "yandex.cloud.ai.vision.v1.Entity")
proto.RegisterType((*Block)(nil), "yandex.cloud.ai.vision.v1.Block")
proto.RegisterType((*Line)(nil), "yandex.cloud.ai.vision.v1.Line")
proto.RegisterType((*Word)(nil), "yandex.cloud.ai.vision.v1.Word")
proto.RegisterType((*Word_DetectedLanguage)(nil), "yandex.cloud.ai.vision.v1.Word.DetectedLanguage")
}
func init() {
proto.RegisterFile("yandex/cloud/ai/vision/v1/text_detection.proto", fileDescriptor_a4d5be2606a8f8f0)
}
var fileDescriptor_a4d5be2606a8f8f0 = []byte{
// 489 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x54, 0xd1, 0x6a, 0x13, 0x41,
0x14, 0x65, 0x93, 0x4d, 0x30, 0x37, 0x51, 0x64, 0x10, 0x59, 0x0b, 0x6a, 0xba, 0xbe, 0x04, 0xa1,
0xb3, 0x6d, 0x45, 0x10, 0xc4, 0x07, 0x63, 0x8b, 0x08, 0x45, 0x64, 0x10, 0x0a, 0xbe, 0x84, 0xdd,
0x9d, 0xeb, 0x66, 0x70, 0x33, 0x37, 0x64, 0x27, 0xe9, 0xe6, 0x03, 0xfc, 0x13, 0x5f, 0xfd, 0x14,
0xff, 0x49, 0x66, 0x26, 0x51, 0x1b, 0x4c, 0xd2, 0x87, 0xbe, 0xcd, 0x3d, 0x9c, 0x73, 0xe6, 0xdc,
0xbb, 0x77, 0x07, 0xf8, 0x32, 0xd5, 0x12, 0xeb, 0x24, 0x2f, 0x69, 0x2e, 0x93, 0x54, 0x25, 0x0b,
0x55, 0x29, 0xd2, 0xc9, 0xe2, 0x24, 0x31, 0x58, 0x9b, 0x91, 0x44, 0x83, 0xb9, 0x51, 0xa4, 0xf9,
0x74, 0x46, 0x86, 0xd8, 0x23, 0xcf, 0xe7, 0x8e, 0xcf, 0x53, 0xc5, 0x3d, 0x9f, 0x2f, 0x4e, 0x0e,
0x9e, 0x6f, 0xb7, 0x9a, 0xce, 0xd4, 0x44, 0x19, 0xb5, 0xc0, 0xca, 0xdb, 0xc4, 0xef, 0xe1, 0xde,
0x67, 0xac, 0xcd, 0x5b, 0xad, 0xc9, 0xa4, 0xd6, 0x9e, 0xbd, 0x84, 0xd6, 0x34, 0x2d, 0xb0, 0x8a,
0x82, 0x7e, 0x73, 0xd0, 0x3d, 0x7d, 0xca, 0xb7, 0x5e, 0xc4, 0x3f, 0xa5, 0x05, 0x0a, 0xcf, 0x8e,
0x7f, 0x06, 0x10, 0xda, 0x9a, 0x3d, 0x80, 0xd6, 0x95, 0x92, 0x66, 0x1c, 0x05, 0xfd, 0x60, 0xd0,
0x14, 0xbe, 0x60, 0x0f, 0xa1, 0x3d, 0x46, 0x55, 0x8c, 0x4d, 0xd4, 0x70, 0xf0, 0xaa, 0x62, 0xaf,
0xa0, 0x9d, 0x95, 0x94, 0x7f, 0xab, 0xa2, 0xa6, 0xbb, 0xae, 0xbf, 0xe3, 0xba, 0xa1, 0x25, 0x8a,
0x15, 0x9f, 0xbd, 0x81, 0x3b, 0xa8, 0x8d, 0x32, 0x0a, 0xab, 0x28, 0x74, 0xda, 0xc3, 0x1d, 0xda,
0x73, 0x4b, 0x5d, 0x8a, 0x3f, 0x92, 0xf8, 0x18, 0xda, 0x1e, 0x63, 0x0c, 0x42, 0x9d, 0x4e, 0xd0,
0xe5, 0xed, 0x08, 0x77, 0xb6, 0x98, 0x9d, 0xba, 0x0b, 0xdb, 0x11, 0xee, 0x1c, 0x7f, 0x0f, 0xa0,
0xe5, 0x22, 0xb0, 0x73, 0xe8, 0x65, 0x34, 0xd7, 0x52, 0xe9, 0x62, 0x94, 0x51, 0xed, 0x94, 0xdd,
0xd3, 0x78, 0xd7, 0xa4, 0xa8, 0x5c, 0x16, 0xa4, 0x45, 0x77, 0xad, 0x1b, 0x52, 0x6d, 0x27, 0x5d,
0x2a, 0x8d, 0x55, 0xd4, 0xd8, 0x3b, 0xe9, 0x0b, 0xa5, 0x51, 0x78, 0x76, 0xfc, 0x23, 0x80, 0xd0,
0xd6, 0xb7, 0x18, 0xe3, 0x8a, 0x66, 0xf2, 0x26, 0x31, 0x2e, 0x69, 0x26, 0x85, 0x67, 0xb3, 0x27,
0x00, 0x39, 0xe9, 0xaf, 0x4a, 0xa2, 0xce, 0x31, 0x6a, 0xf6, 0x83, 0x41, 0x20, 0xfe, 0x41, 0xe2,
0x5f, 0x0d, 0x08, 0x2d, 0xff, 0xb6, 0x62, 0xfe, 0xe7, 0x93, 0xec, 0xcb, 0xc0, 0x3e, 0x42, 0xa7,
0x4c, 0x75, 0x31, 0x77, 0xfb, 0xec, 0x97, 0xe4, 0x78, 0x4f, 0x7b, 0xfc, 0xcc, 0xfd, 0x68, 0x28,
0x2f, 0x56, 0x42, 0xf1, 0xd7, 0x82, 0x1d, 0x42, 0xcf, 0x2d, 0xd0, 0x72, 0xa4, 0xac, 0x47, 0xd4,
0x72, 0xbb, 0xdc, 0xf5, 0xd8, 0x07, 0x0b, 0x1d, 0x5c, 0xc2, 0xfd, 0x4d, 0x07, 0xf6, 0x0c, 0xee,
0xae, 0x3d, 0x46, 0x39, 0xc9, 0xf5, 0xaa, 0xf5, 0xd6, 0xe0, 0x3b, 0x92, 0xb8, 0xd1, 0x4b, 0x63,
0xb3, 0x97, 0x21, 0xc2, 0xe3, 0xeb, 0xc9, 0xa7, 0xea, 0x5a, 0xfa, 0x2f, 0x67, 0x85, 0x32, 0xe3,
0x79, 0xc6, 0x73, 0x9a, 0x24, 0x9e, 0x79, 0xe4, 0x5f, 0x80, 0x82, 0x8e, 0x0a, 0xd4, 0xee, 0x7f,
0x4f, 0xb6, 0x3e, 0x0d, 0xaf, 0xfd, 0x29, 0x6b, 0x3b, 0xde, 0x8b, 0xdf, 0x01, 0x00, 0x00, 0xff,
0xff, 0x00, 0xe2, 0x5b, 0x71, 0x90, 0x04, 0x00, 0x00,
}

79
vendor/github.com/yandex-cloud/go-genproto/yandex/cloud/ai/vision/v1/text_detection.pbext.go generated vendored Normal file
View file

@ -0,0 +1,79 @@
// Code generated by protoc-gen-goext. DO NOT EDIT.
package vision
func (m *TextAnnotation) SetPages(v []*Page) {
m.Pages = v
}
func (m *Page) SetWidth(v int64) {
m.Width = v
}
func (m *Page) SetHeight(v int64) {
m.Height = v
}
func (m *Page) SetBlocks(v []*Block) {
m.Blocks = v
}
func (m *Page) SetEntities(v []*Entity) {
m.Entities = v
}
func (m *Entity) SetName(v string) {
m.Name = v
}
func (m *Entity) SetText(v string) {
m.Text = v
}
func (m *Block) SetBoundingBox(v *Polygon) {
m.BoundingBox = v
}
func (m *Block) SetLines(v []*Line) {
m.Lines = v
}
func (m *Line) SetBoundingBox(v *Polygon) {
m.BoundingBox = v
}
func (m *Line) SetWords(v []*Word) {
m.Words = v
}
func (m *Line) SetConfidence(v float64) {
m.Confidence = v
}
func (m *Word) SetBoundingBox(v *Polygon) {
m.BoundingBox = v
}
func (m *Word) SetText(v string) {
m.Text = v
}
func (m *Word) SetConfidence(v float64) {
m.Confidence = v
}
func (m *Word) SetLanguages(v []*Word_DetectedLanguage) {
m.Languages = v
}
func (m *Word) SetEntityIndex(v int64) {
m.EntityIndex = v
}
func (m *Word_DetectedLanguage) SetLanguageCode(v string) {
m.LanguageCode = v
}
func (m *Word_DetectedLanguage) SetConfidence(v float64) {
m.Confidence = v
}

775
vendor/github.com/yandex-cloud/go-genproto/yandex/cloud/ai/vision/v1/vision_service.pb.go generated vendored Normal file
View file

@ -0,0 +1,775 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
// source: yandex/cloud/ai/vision/v1/vision_service.proto
package vision
import (
context "context"
fmt "fmt"
proto "github.com/golang/protobuf/proto"
_ "github.com/yandex-cloud/go-genproto/yandex/cloud"
_ "google.golang.org/genproto/googleapis/api/annotations"
status "google.golang.org/genproto/googleapis/rpc/status"
grpc "google.golang.org/grpc"
codes "google.golang.org/grpc/codes"
status1 "google.golang.org/grpc/status"
math "math"
)
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf
// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.ProtoPackageIsVersion3 // please upgrade the proto package
type Feature_Type int32
const (
Feature_TYPE_UNSPECIFIED Feature_Type = 0
// Text detection (OCR) feature.
Feature_TEXT_DETECTION Feature_Type = 1
// Classification feature.
Feature_CLASSIFICATION Feature_Type = 2
// Face detection feature.
Feature_FACE_DETECTION Feature_Type = 3
// Image copy search.
Feature_IMAGE_COPY_SEARCH Feature_Type = 4
)
var Feature_Type_name = map[int32]string{
0: "TYPE_UNSPECIFIED",
1: "TEXT_DETECTION",
2: "CLASSIFICATION",
3: "FACE_DETECTION",
4: "IMAGE_COPY_SEARCH",
}
var Feature_Type_value = map[string]int32{
"TYPE_UNSPECIFIED": 0,
"TEXT_DETECTION": 1,
"CLASSIFICATION": 2,
"FACE_DETECTION": 3,
"IMAGE_COPY_SEARCH": 4,
}
func (x Feature_Type) String() string {
return proto.EnumName(Feature_Type_name, int32(x))
}
func (Feature_Type) EnumDescriptor() ([]byte, []int) {
return fileDescriptor_6d06b6b52fd28cc5, []int{2, 0}
}
type BatchAnalyzeRequest struct {
// A list of specifications. Each specification contains the file to analyze and features to use for analysis.
//
// Restrictions:
// * Supported file formats: JPEG, PNG.
// * Maximum file size: 1 MB.
// * Image size should not exceed 20M pixels (length x width).
AnalyzeSpecs []*AnalyzeSpec `protobuf:"bytes,1,rep,name=analyze_specs,json=analyzeSpecs,proto3" json:"analyze_specs,omitempty"`
// ID of the folder to which you have access.
// Required for authorization with a user account (see [yandex.cloud.iam.v1.UserAccount] resource).
// Don't specify this field if you make the request on behalf of a service account.
FolderId string `protobuf:"bytes,2,opt,name=folder_id,json=folderId,proto3" json:"folder_id,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *BatchAnalyzeRequest) Reset() { *m = BatchAnalyzeRequest{} }
func (m *BatchAnalyzeRequest) String() string { return proto.CompactTextString(m) }
func (*BatchAnalyzeRequest) ProtoMessage() {}
func (*BatchAnalyzeRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_6d06b6b52fd28cc5, []int{0}
}
func (m *BatchAnalyzeRequest) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_BatchAnalyzeRequest.Unmarshal(m, b)
}
func (m *BatchAnalyzeRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_BatchAnalyzeRequest.Marshal(b, m, deterministic)
}
func (m *BatchAnalyzeRequest) XXX_Merge(src proto.Message) {
xxx_messageInfo_BatchAnalyzeRequest.Merge(m, src)
}
func (m *BatchAnalyzeRequest) XXX_Size() int {
return xxx_messageInfo_BatchAnalyzeRequest.Size(m)
}
func (m *BatchAnalyzeRequest) XXX_DiscardUnknown() {
xxx_messageInfo_BatchAnalyzeRequest.DiscardUnknown(m)
}
var xxx_messageInfo_BatchAnalyzeRequest proto.InternalMessageInfo
func (m *BatchAnalyzeRequest) GetAnalyzeSpecs() []*AnalyzeSpec {
if m != nil {
return m.AnalyzeSpecs
}
return nil
}
func (m *BatchAnalyzeRequest) GetFolderId() string {
if m != nil {
return m.FolderId
}
return ""
}
type AnalyzeSpec struct {
// Types that are valid to be assigned to Source:
// *AnalyzeSpec_Content
// *AnalyzeSpec_Signature
Source isAnalyzeSpec_Source `protobuf_oneof:"source"`
// Requested features to use for analysis.
//
// Max count of requested features for one file is 8.
Features []*Feature `protobuf:"bytes,3,rep,name=features,proto3" json:"features,omitempty"`
// [MIME type](https://en.wikipedia.org/wiki/Media_type) of content (for example, `` application/pdf ``).
MimeType string `protobuf:"bytes,4,opt,name=mime_type,json=mimeType,proto3" json:"mime_type,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *AnalyzeSpec) Reset() { *m = AnalyzeSpec{} }
func (m *AnalyzeSpec) String() string { return proto.CompactTextString(m) }
func (*AnalyzeSpec) ProtoMessage() {}
func (*AnalyzeSpec) Descriptor() ([]byte, []int) {
return fileDescriptor_6d06b6b52fd28cc5, []int{1}
}
func (m *AnalyzeSpec) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_AnalyzeSpec.Unmarshal(m, b)
}
func (m *AnalyzeSpec) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_AnalyzeSpec.Marshal(b, m, deterministic)
}
func (m *AnalyzeSpec) XXX_Merge(src proto.Message) {
xxx_messageInfo_AnalyzeSpec.Merge(m, src)
}
func (m *AnalyzeSpec) XXX_Size() int {
return xxx_messageInfo_AnalyzeSpec.Size(m)
}
func (m *AnalyzeSpec) XXX_DiscardUnknown() {
xxx_messageInfo_AnalyzeSpec.DiscardUnknown(m)
}
var xxx_messageInfo_AnalyzeSpec proto.InternalMessageInfo
type isAnalyzeSpec_Source interface {
isAnalyzeSpec_Source()
}
type AnalyzeSpec_Content struct {
Content []byte `protobuf:"bytes,1,opt,name=content,proto3,oneof"`
}
type AnalyzeSpec_Signature struct {
Signature string `protobuf:"bytes,5,opt,name=signature,proto3,oneof"`
}
func (*AnalyzeSpec_Content) isAnalyzeSpec_Source() {}
func (*AnalyzeSpec_Signature) isAnalyzeSpec_Source() {}
func (m *AnalyzeSpec) GetSource() isAnalyzeSpec_Source {
if m != nil {
return m.Source
}
return nil
}
func (m *AnalyzeSpec) GetContent() []byte {
if x, ok := m.GetSource().(*AnalyzeSpec_Content); ok {
return x.Content
}
return nil
}
func (m *AnalyzeSpec) GetSignature() string {
if x, ok := m.GetSource().(*AnalyzeSpec_Signature); ok {
return x.Signature
}
return ""
}
func (m *AnalyzeSpec) GetFeatures() []*Feature {
if m != nil {
return m.Features
}
return nil
}
func (m *AnalyzeSpec) GetMimeType() string {
if m != nil {
return m.MimeType
}
return ""
}
// XXX_OneofWrappers is for the internal use of the proto package.
func (*AnalyzeSpec) XXX_OneofWrappers() []interface{} {
return []interface{}{
(*AnalyzeSpec_Content)(nil),
(*AnalyzeSpec_Signature)(nil),
}
}
type Feature struct {
// Type of requested feature.
Type Feature_Type `protobuf:"varint,1,opt,name=type,proto3,enum=yandex.cloud.ai.vision.v1.Feature_Type" json:"type,omitempty"`
// Types that are valid to be assigned to Config:
// *Feature_ClassificationConfig
// *Feature_TextDetectionConfig
Config isFeature_Config `protobuf_oneof:"config"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *Feature) Reset() { *m = Feature{} }
func (m *Feature) String() string { return proto.CompactTextString(m) }
func (*Feature) ProtoMessage() {}
func (*Feature) Descriptor() ([]byte, []int) {
return fileDescriptor_6d06b6b52fd28cc5, []int{2}
}
func (m *Feature) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_Feature.Unmarshal(m, b)
}
func (m *Feature) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_Feature.Marshal(b, m, deterministic)
}
func (m *Feature) XXX_Merge(src proto.Message) {
xxx_messageInfo_Feature.Merge(m, src)
}
func (m *Feature) XXX_Size() int {
return xxx_messageInfo_Feature.Size(m)
}
func (m *Feature) XXX_DiscardUnknown() {
xxx_messageInfo_Feature.DiscardUnknown(m)
}
var xxx_messageInfo_Feature proto.InternalMessageInfo
func (m *Feature) GetType() Feature_Type {
if m != nil {
return m.Type
}
return Feature_TYPE_UNSPECIFIED
}
type isFeature_Config interface {
isFeature_Config()
}
type Feature_ClassificationConfig struct {
ClassificationConfig *FeatureClassificationConfig `protobuf:"bytes,2,opt,name=classification_config,json=classificationConfig,proto3,oneof"`
}
type Feature_TextDetectionConfig struct {
TextDetectionConfig *FeatureTextDetectionConfig `protobuf:"bytes,3,opt,name=text_detection_config,json=textDetectionConfig,proto3,oneof"`
}
func (*Feature_ClassificationConfig) isFeature_Config() {}
func (*Feature_TextDetectionConfig) isFeature_Config() {}
func (m *Feature) GetConfig() isFeature_Config {
if m != nil {
return m.Config
}
return nil
}
func (m *Feature) GetClassificationConfig() *FeatureClassificationConfig {
if x, ok := m.GetConfig().(*Feature_ClassificationConfig); ok {
return x.ClassificationConfig
}
return nil
}
func (m *Feature) GetTextDetectionConfig() *FeatureTextDetectionConfig {
if x, ok := m.GetConfig().(*Feature_TextDetectionConfig); ok {
return x.TextDetectionConfig
}
return nil
}
// XXX_OneofWrappers is for the internal use of the proto package.
func (*Feature) XXX_OneofWrappers() []interface{} {
return []interface{}{
(*Feature_ClassificationConfig)(nil),
(*Feature_TextDetectionConfig)(nil),
}
}
type FeatureClassificationConfig struct {
// Model to use for image classification.
Model string `protobuf:"bytes,1,opt,name=model,proto3" json:"model,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *FeatureClassificationConfig) Reset() { *m = FeatureClassificationConfig{} }
func (m *FeatureClassificationConfig) String() string { return proto.CompactTextString(m) }
func (*FeatureClassificationConfig) ProtoMessage() {}
func (*FeatureClassificationConfig) Descriptor() ([]byte, []int) {
return fileDescriptor_6d06b6b52fd28cc5, []int{3}
}
func (m *FeatureClassificationConfig) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_FeatureClassificationConfig.Unmarshal(m, b)
}
func (m *FeatureClassificationConfig) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_FeatureClassificationConfig.Marshal(b, m, deterministic)
}
func (m *FeatureClassificationConfig) XXX_Merge(src proto.Message) {
xxx_messageInfo_FeatureClassificationConfig.Merge(m, src)
}
func (m *FeatureClassificationConfig) XXX_Size() int {
return xxx_messageInfo_FeatureClassificationConfig.Size(m)
}
func (m *FeatureClassificationConfig) XXX_DiscardUnknown() {
xxx_messageInfo_FeatureClassificationConfig.DiscardUnknown(m)
}
var xxx_messageInfo_FeatureClassificationConfig proto.InternalMessageInfo
func (m *FeatureClassificationConfig) GetModel() string {
if m != nil {
return m.Model
}
return ""
}
type FeatureTextDetectionConfig struct {
// List of the languages to recognize text.
// Specified in [ISO 639-1](https://en.wikipedia.org/wiki/ISO_639-1) format (for example, `` ru ``).
LanguageCodes []string `protobuf:"bytes,1,rep,name=language_codes,json=languageCodes,proto3" json:"language_codes,omitempty"`
// Model to use for text detection.
// Possible values:
// * page (default) — this model is suitable for detecting multiple text entries in an image.
// * line — this model is suitable for cropped images with one line of text.
Model string `protobuf:"bytes,2,opt,name=model,proto3" json:"model,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *FeatureTextDetectionConfig) Reset() { *m = FeatureTextDetectionConfig{} }
func (m *FeatureTextDetectionConfig) String() string { return proto.CompactTextString(m) }
func (*FeatureTextDetectionConfig) ProtoMessage() {}
func (*FeatureTextDetectionConfig) Descriptor() ([]byte, []int) {
return fileDescriptor_6d06b6b52fd28cc5, []int{4}
}
func (m *FeatureTextDetectionConfig) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_FeatureTextDetectionConfig.Unmarshal(m, b)
}
func (m *FeatureTextDetectionConfig) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_FeatureTextDetectionConfig.Marshal(b, m, deterministic)
}
func (m *FeatureTextDetectionConfig) XXX_Merge(src proto.Message) {
xxx_messageInfo_FeatureTextDetectionConfig.Merge(m, src)
}
func (m *FeatureTextDetectionConfig) XXX_Size() int {
return xxx_messageInfo_FeatureTextDetectionConfig.Size(m)
}
func (m *FeatureTextDetectionConfig) XXX_DiscardUnknown() {
xxx_messageInfo_FeatureTextDetectionConfig.DiscardUnknown(m)
}
var xxx_messageInfo_FeatureTextDetectionConfig proto.InternalMessageInfo
func (m *FeatureTextDetectionConfig) GetLanguageCodes() []string {
if m != nil {
return m.LanguageCodes
}
return nil
}
func (m *FeatureTextDetectionConfig) GetModel() string {
if m != nil {
return m.Model
}
return ""
}
type BatchAnalyzeResponse struct {
// Request results.
// Results have the same order as specifications in the request.
Results []*AnalyzeResult `protobuf:"bytes,1,rep,name=results,proto3" json:"results,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *BatchAnalyzeResponse) Reset() { *m = BatchAnalyzeResponse{} }
func (m *BatchAnalyzeResponse) String() string { return proto.CompactTextString(m) }
func (*BatchAnalyzeResponse) ProtoMessage() {}
func (*BatchAnalyzeResponse) Descriptor() ([]byte, []int) {
return fileDescriptor_6d06b6b52fd28cc5, []int{5}
}
func (m *BatchAnalyzeResponse) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_BatchAnalyzeResponse.Unmarshal(m, b)
}
func (m *BatchAnalyzeResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_BatchAnalyzeResponse.Marshal(b, m, deterministic)
}
func (m *BatchAnalyzeResponse) XXX_Merge(src proto.Message) {
xxx_messageInfo_BatchAnalyzeResponse.Merge(m, src)
}
func (m *BatchAnalyzeResponse) XXX_Size() int {
return xxx_messageInfo_BatchAnalyzeResponse.Size(m)
}
func (m *BatchAnalyzeResponse) XXX_DiscardUnknown() {
xxx_messageInfo_BatchAnalyzeResponse.DiscardUnknown(m)
}
var xxx_messageInfo_BatchAnalyzeResponse proto.InternalMessageInfo
func (m *BatchAnalyzeResponse) GetResults() []*AnalyzeResult {
if m != nil {
return m.Results
}
return nil
}
type AnalyzeResult struct {
// Results for each requested feature.
// Feature results have the same order as in the request.
Results []*FeatureResult `protobuf:"bytes,2,rep,name=results,proto3" json:"results,omitempty"`
// Return error in case of error with file processing.
Error *status.Status `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *AnalyzeResult) Reset() { *m = AnalyzeResult{} }
func (m *AnalyzeResult) String() string { return proto.CompactTextString(m) }
func (*AnalyzeResult) ProtoMessage() {}
func (*AnalyzeResult) Descriptor() ([]byte, []int) {
return fileDescriptor_6d06b6b52fd28cc5, []int{6}
}
func (m *AnalyzeResult) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_AnalyzeResult.Unmarshal(m, b)
}
func (m *AnalyzeResult) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_AnalyzeResult.Marshal(b, m, deterministic)
}
func (m *AnalyzeResult) XXX_Merge(src proto.Message) {
xxx_messageInfo_AnalyzeResult.Merge(m, src)
}
func (m *AnalyzeResult) XXX_Size() int {
return xxx_messageInfo_AnalyzeResult.Size(m)
}
func (m *AnalyzeResult) XXX_DiscardUnknown() {
xxx_messageInfo_AnalyzeResult.DiscardUnknown(m)
}
var xxx_messageInfo_AnalyzeResult proto.InternalMessageInfo
func (m *AnalyzeResult) GetResults() []*FeatureResult {
if m != nil {
return m.Results
}
return nil
}
func (m *AnalyzeResult) GetError() *status.Status {
if m != nil {
return m.Error
}
return nil
}
type FeatureResult struct {
// Types that are valid to be assigned to Feature:
// *FeatureResult_TextDetection
// *FeatureResult_Classification
// *FeatureResult_FaceDetection
// *FeatureResult_ImageCopySearch
Feature isFeatureResult_Feature `protobuf_oneof:"feature"`
// Return error in case of error during the specified feature processing.
Error *status.Status `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *FeatureResult) Reset() { *m = FeatureResult{} }
func (m *FeatureResult) String() string { return proto.CompactTextString(m) }
func (*FeatureResult) ProtoMessage() {}
func (*FeatureResult) Descriptor() ([]byte, []int) {
return fileDescriptor_6d06b6b52fd28cc5, []int{7}
}
func (m *FeatureResult) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_FeatureResult.Unmarshal(m, b)
}
func (m *FeatureResult) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_FeatureResult.Marshal(b, m, deterministic)
}
func (m *FeatureResult) XXX_Merge(src proto.Message) {
xxx_messageInfo_FeatureResult.Merge(m, src)
}
func (m *FeatureResult) XXX_Size() int {
return xxx_messageInfo_FeatureResult.Size(m)
}
func (m *FeatureResult) XXX_DiscardUnknown() {
xxx_messageInfo_FeatureResult.DiscardUnknown(m)
}
var xxx_messageInfo_FeatureResult proto.InternalMessageInfo
type isFeatureResult_Feature interface {
isFeatureResult_Feature()
}
type FeatureResult_TextDetection struct {
TextDetection *TextAnnotation `protobuf:"bytes,2,opt,name=text_detection,json=textDetection,proto3,oneof"`
}
type FeatureResult_Classification struct {
Classification *ClassAnnotation `protobuf:"bytes,3,opt,name=classification,proto3,oneof"`
}
type FeatureResult_FaceDetection struct {
FaceDetection *FaceAnnotation `protobuf:"bytes,4,opt,name=face_detection,json=faceDetection,proto3,oneof"`
}
type FeatureResult_ImageCopySearch struct {
ImageCopySearch *ImageCopySearchAnnotation `protobuf:"bytes,5,opt,name=image_copy_search,json=imageCopySearch,proto3,oneof"`
}
func (*FeatureResult_TextDetection) isFeatureResult_Feature() {}
func (*FeatureResult_Classification) isFeatureResult_Feature() {}
func (*FeatureResult_FaceDetection) isFeatureResult_Feature() {}
func (*FeatureResult_ImageCopySearch) isFeatureResult_Feature() {}
func (m *FeatureResult) GetFeature() isFeatureResult_Feature {
if m != nil {
return m.Feature
}
return nil
}
func (m *FeatureResult) GetTextDetection() *TextAnnotation {
if x, ok := m.GetFeature().(*FeatureResult_TextDetection); ok {
return x.TextDetection
}
return nil
}
func (m *FeatureResult) GetClassification() *ClassAnnotation {
if x, ok := m.GetFeature().(*FeatureResult_Classification); ok {
return x.Classification
}
return nil
}
func (m *FeatureResult) GetFaceDetection() *FaceAnnotation {
if x, ok := m.GetFeature().(*FeatureResult_FaceDetection); ok {
return x.FaceDetection
}
return nil
}
func (m *FeatureResult) GetImageCopySearch() *ImageCopySearchAnnotation {
if x, ok := m.GetFeature().(*FeatureResult_ImageCopySearch); ok {
return x.ImageCopySearch
}
return nil
}
func (m *FeatureResult) GetError() *status.Status {
if m != nil {
return m.Error
}
return nil
}
// XXX_OneofWrappers is for the internal use of the proto package.
func (*FeatureResult) XXX_OneofWrappers() []interface{} {
return []interface{}{
(*FeatureResult_TextDetection)(nil),
(*FeatureResult_Classification)(nil),
(*FeatureResult_FaceDetection)(nil),
(*FeatureResult_ImageCopySearch)(nil),
}
}
func init() {
proto.RegisterEnum("yandex.cloud.ai.vision.v1.Feature_Type", Feature_Type_name, Feature_Type_value)
proto.RegisterType((*BatchAnalyzeRequest)(nil), "yandex.cloud.ai.vision.v1.BatchAnalyzeRequest")
proto.RegisterType((*AnalyzeSpec)(nil), "yandex.cloud.ai.vision.v1.AnalyzeSpec")
proto.RegisterType((*Feature)(nil), "yandex.cloud.ai.vision.v1.Feature")
proto.RegisterType((*FeatureClassificationConfig)(nil), "yandex.cloud.ai.vision.v1.FeatureClassificationConfig")
proto.RegisterType((*FeatureTextDetectionConfig)(nil), "yandex.cloud.ai.vision.v1.FeatureTextDetectionConfig")
proto.RegisterType((*BatchAnalyzeResponse)(nil), "yandex.cloud.ai.vision.v1.BatchAnalyzeResponse")
proto.RegisterType((*AnalyzeResult)(nil), "yandex.cloud.ai.vision.v1.AnalyzeResult")
proto.RegisterType((*FeatureResult)(nil), "yandex.cloud.ai.vision.v1.FeatureResult")
}
func init() {
proto.RegisterFile("yandex/cloud/ai/vision/v1/vision_service.proto", fileDescriptor_6d06b6b52fd28cc5)
}
var fileDescriptor_6d06b6b52fd28cc5 = []byte{
// 941 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x8c, 0x55, 0x41, 0x6f, 0xe2, 0xc6,
0x17, 0xc7, 0x81, 0x04, 0x78, 0x04, 0xfe, 0xd9, 0xd9, 0x44, 0xcb, 0x3f, 0xdd, 0x6d, 0x23, 0x4b,
0xdd, 0xd2, 0x54, 0xb1, 0x63, 0x12, 0xd2, 0xa8, 0x0b, 0x95, 0xb0, 0x03, 0x0b, 0x52, 0xbb, 0x1b,
0x19, 0x5a, 0x75, 0xf7, 0x62, 0x4d, 0x86, 0x81, 0x58, 0x05, 0xdb, 0xb5, 0x07, 0x14, 0x2a, 0xf5,
0xb2, 0x47, 0x8e, 0xdd, 0x73, 0x8f, 0xed, 0xe7, 0x68, 0x6f, 0xdc, 0xfb, 0x15, 0x2a, 0xf5, 0x6b,
0x54, 0x1e, 0x9b, 0x04, 0x27, 0x1b, 0x93, 0xdb, 0xe8, 0xbd, 0xdf, 0xfb, 0xbd, 0xf7, 0x66, 0x7e,
0x6f, 0x1e, 0x48, 0x53, 0x6c, 0xf5, 0xe8, 0x95, 0x4c, 0x86, 0xf6, 0xb8, 0x27, 0x63, 0x53, 0x9e,
0x98, 0x9e, 0x69, 0x5b, 0xf2, 0x44, 0x09, 0x4f, 0x86, 0x47, 0xdd, 0x89, 0x49, 0xa8, 0xe4, 0xb8,
0x36, 0xb3, 0xd1, 0xff, 0x03, 0xbc, 0xc4, 0xf1, 0x12, 0x36, 0xa5, 0x00, 0x25, 0x4d, 0x94, 0xdd,
0x18, 0x2a, 0x46, 0xaf, 0x98, 0xd1, 0xa3, 0x8c, 0x12, 0xe6, 0x83, 0x39, 0x55, 0x1c, 0x9e, 0x0c,
0xb1, 0xe7, 0x99, 0x7d, 0x93, 0xe0, 0x87, 0xe1, 0xfb, 0x98, 0xd0, 0x3b, 0xfc, 0xca, 0xfd, 0x78,
0x73, 0x84, 0x07, 0xd4, 0x20, 0xb6, 0x33, 0x35, 0x3c, 0x8a, 0x5d, 0x72, 0x19, 0x86, 0x3c, 0x8b,
0x84, 0x4c, 0xf0, 0xd0, 0xec, 0x2d, 0x57, 0xf0, 0x74, 0x60, 0xdb, 0x83, 0x21, 0x95, 0xb1, 0x63,
0xca, 0xd8, 0xb2, 0x6c, 0xc6, 0x9d, 0x5e, 0xe8, 0x7d, 0x12, 0x7a, 0x5d, 0x87, 0xc8, 0x1e, 0xc3,
0x6c, 0x1c, 0x3a, 0xc4, 0x5f, 0x05, 0x78, 0xac, 0x62, 0x46, 0x2e, 0xeb, 0x16, 0x1e, 0x4e, 0x7f,
0xa6, 0x3a, 0xfd, 0x69, 0x4c, 0x3d, 0x86, 0xba, 0x90, 0xc7, 0x81, 0xc5, 0xf0, 0x1c, 0x4a, 0xbc,
0xa2, 0xb0, 0x97, 0x2c, 0xe5, 0xca, 0xcf, 0xa5, 0x7b, 0xef, 0x58, 0x0a, 0x19, 0x3a, 0x0e, 0x25,
0x6a, 0xfa, 0xdd, 0x5c, 0x49, 0x2a, 0x07, 0xa7, 0xfa, 0x26, 0xbe, 0xb1, 0x7a, 0xe8, 0x53, 0xc8,
0xf6, 0xed, 0x61, 0x8f, 0xba, 0x86, 0xd9, 0x2b, 0xae, 0xed, 0x09, 0xa5, 0xac, 0x9a, 0x99, 0xcd,
0x95, 0x54, 0xb5, 0x56, 0x39, 0xd4, 0x33, 0x81, 0xab, 0xdd, 0x13, 0xff, 0x15, 0x20, 0xb7, 0xc4,
0x86, 0xf6, 0x21, 0x4d, 0x6c, 0x8b, 0x51, 0x8b, 0x15, 0x85, 0x3d, 0xa1, 0xb4, 0xa9, 0x16, 0x66,
0x73, 0x05, 0xaa, 0x35, 0xe5, 0xf0, 0xf8, 0xb4, 0xf2, 0xe5, 0xc9, 0x61, 0x2b, 0xa1, 0x2f, 0x00,
0xe8, 0x0b, 0xc8, 0x7a, 0xe6, 0xc0, 0xc2, 0x6c, 0xec, 0xd2, 0xe2, 0x3a, 0x4f, 0x91, 0x9b, 0xcd,
0x95, 0x74, 0xb5, 0xa6, 0x9c, 0x1c, 0x9d, 0x1e, 0xb7, 0x12, 0xfa, 0x8d, 0x1f, 0xbd, 0x84, 0x4c,
0x9f, 0xf2, 0xa3, 0x57, 0x4c, 0xf2, 0x06, 0xc5, 0x98, 0x06, 0x9b, 0x01, 0xf4, 0xa6, 0xb9, 0xeb,
0x60, 0xf4, 0x1c, 0xb2, 0x23, 0x73, 0x44, 0x0d, 0x36, 0x75, 0x68, 0x31, 0xc5, 0xb3, 0x66, 0x67,
0x73, 0x65, 0xbd, 0x5a, 0x2b, 0x57, 0x2a, 0x7a, 0xc6, 0xf7, 0x75, 0xa7, 0x0e, 0x55, 0x0b, 0xb0,
0xe1, 0xd9, 0x63, 0x97, 0x50, 0x94, 0xfa, 0xf3, 0x2f, 0x45, 0x10, 0x7f, 0x4b, 0x42, 0x3a, 0xa4,
0x45, 0x2f, 0x20, 0xc5, 0xc3, 0xfd, 0x16, 0x0b, 0xe5, 0xcf, 0x56, 0x17, 0x22, 0xf9, 0x94, 0x3a,
0x0f, 0x42, 0x23, 0xd8, 0x89, 0x0a, 0xd3, 0x20, 0xb6, 0xd5, 0x37, 0x07, 0xfc, 0x96, 0x73, 0xe5,
0x93, 0xd5, 0x6c, 0x5a, 0x24, 0x5c, 0xe3, 0xd1, 0xad, 0x84, 0xbe, 0x4d, 0x3e, 0x60, 0x47, 0x3f,
0xc2, 0x4e, 0x74, 0x6e, 0x16, 0xe9, 0x92, 0x3c, 0x5d, 0x65, 0x75, 0xba, 0x2e, 0xbd, 0x62, 0x67,
0x8b, 0xe8, 0xeb, 0x6c, 0x8f, 0xd9, 0x5d, 0xb3, 0x68, 0x43, 0xca, 0xef, 0x14, 0x6d, 0xc3, 0x56,
0xf7, 0xcd, 0x79, 0xc3, 0xf8, 0xee, 0x55, 0xe7, 0xbc, 0xa1, 0xb5, 0x9b, 0xed, 0xc6, 0xd9, 0x56,
0x02, 0x21, 0x28, 0x74, 0x1b, 0x3f, 0x74, 0x8d, 0xb3, 0x46, 0xb7, 0xa1, 0x75, 0xdb, 0xaf, 0x5f,
0x6d, 0x09, 0xbe, 0x4d, 0xfb, 0xa6, 0xde, 0xe9, 0xb4, 0x9b, 0x6d, 0xad, 0xce, 0x6d, 0x6b, 0xbe,
0xad, 0x59, 0xd7, 0x1a, 0x4b, 0xb8, 0x24, 0xda, 0x81, 0x47, 0xed, 0x6f, 0xeb, 0x2f, 0x1b, 0x86,
0xf6, 0xfa, 0xfc, 0x8d, 0xd1, 0x69, 0xd4, 0x75, 0xad, 0xb5, 0x95, 0x52, 0x33, 0xb0, 0x11, 0xb4,
0x23, 0x7e, 0x0d, 0x1f, 0xc5, 0x5c, 0x0f, 0xfa, 0x04, 0xd6, 0x47, 0x76, 0x8f, 0x0e, 0xf9, 0x9b,
0x2d, 0x3d, 0xf9, 0x89, 0x1e, 0xd8, 0x45, 0x0f, 0x76, 0xef, 0xef, 0x17, 0x55, 0xa0, 0x30, 0xc4,
0xd6, 0x60, 0x1c, 0x0c, 0x7c, 0x8f, 0x06, 0x53, 0x96, 0x55, 0x0b, 0xa1, 0xc0, 0x66, 0x73, 0x25,
0x59, 0xad, 0x1d, 0xe9, 0xf9, 0x05, 0x4a, 0xf3, 0x41, 0xe8, 0xe3, 0x45, 0xd6, 0xdb, 0x13, 0x14,
0x26, 0x7d, 0x0b, 0xdb, 0xd1, 0x91, 0xf6, 0x1c, 0xdb, 0xf2, 0x28, 0x52, 0x21, 0xed, 0x52, 0x6f,
0x3c, 0x64, 0x8b, 0x69, 0x2e, 0xad, 0x9e, 0x66, 0x9d, 0x07, 0xe8, 0x8b, 0x40, 0xf1, 0x17, 0xc8,
0x47, 0x3c, 0xcb, 0xa4, 0x6b, 0x2b, 0x49, 0xc3, 0xbb, 0xb8, 0x45, 0x8a, 0x4a, 0xb0, 0x4e, 0x5d,
0xd7, 0x76, 0xf9, 0x35, 0xe6, 0xca, 0x48, 0x0a, 0x7e, 0x2b, 0xc9, 0x75, 0x88, 0xd4, 0xe1, 0xbf,
0x95, 0x1e, 0x00, 0xc4, 0x3f, 0x92, 0x90, 0x8f, 0x90, 0x20, 0x1d, 0x0a, 0x51, 0x25, 0x86, 0x8a,
0xff, 0x3c, 0xa6, 0x0c, 0xff, 0x2d, 0xea, 0xd7, 0x7f, 0x64, 0x2b, 0xa1, 0xe7, 0x23, 0xb2, 0x43,
0x5d, 0x28, 0x44, 0x55, 0x1f, 0xca, 0x7a, 0x3f, 0x86, 0x93, 0xeb, 0x23, 0x42, 0x7a, 0x8b, 0xc3,
0xaf, 0x34, 0xba, 0x0b, 0xf8, 0x47, 0x11, 0x5f, 0x69, 0x13, 0x13, 0x1a, 0xad, 0xd4, 0xa7, 0xb8,
0xa9, 0xf4, 0x02, 0x1e, 0xdd, 0xd9, 0x17, 0xfc, 0xd7, 0xcb, 0x95, 0x8f, 0x63, 0x68, 0xdb, 0x23,
0x2e, 0x26, 0x67, 0xda, 0xe1, 0x11, 0x91, 0x0c, 0xff, 0x33, 0xa3, 0xce, 0x87, 0xbf, 0x8e, 0x9a,
0x85, 0x74, 0xf8, 0x23, 0x96, 0x7f, 0x17, 0x20, 0xff, 0x3d, 0xcf, 0xd7, 0x09, 0x76, 0x34, 0x7a,
0x2f, 0xc0, 0xe6, 0xb2, 0x2c, 0x91, 0x14, 0x53, 0xe0, 0x07, 0x56, 0xd2, 0xae, 0xfc, 0x60, 0x7c,
0xa0, 0x77, 0x51, 0x7c, 0xf7, 0xf7, 0x3f, 0xef, 0xd7, 0x9e, 0x8a, 0x4f, 0x96, 0xb6, 0xeb, 0xc5,
0x12, 0xf0, 0x2b, 0x61, 0x5f, 0xa5, 0xf0, 0x2c, 0xca, 0xea, 0x98, 0x11, 0xe6, 0xb7, 0x67, 0x03,
0x93, 0x5d, 0x8e, 0x2f, 0x24, 0x62, 0x8f, 0xe4, 0x00, 0x79, 0x10, 0x6c, 0xe0, 0x81, 0x7d, 0x30,
0xa0, 0x16, 0xdf, 0xa2, 0xf2, 0xbd, 0xdb, 0xfc, 0x45, 0x70, 0xba, 0xd8, 0xe0, 0xb8, 0xa3, 0xff,
0x02, 0x00, 0x00, 0xff, 0xff, 0x1a, 0xe9, 0xa0, 0xc9, 0xd3, 0x08, 0x00, 0x00,
}
// Reference imports to suppress errors if they are not otherwise used.
var _ context.Context
var _ grpc.ClientConnInterface
// This is a compile-time assertion to ensure that this generated file
// is compatible with the grpc package it is being compiled against.
const _ = grpc.SupportPackageIsVersion6
// VisionServiceClient is the client API for VisionService service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type VisionServiceClient interface {
// Analyzes a batch of images and returns results with annotations.
BatchAnalyze(ctx context.Context, in *BatchAnalyzeRequest, opts ...grpc.CallOption) (*BatchAnalyzeResponse, error)
}
type visionServiceClient struct {
cc grpc.ClientConnInterface
}
func NewVisionServiceClient(cc grpc.ClientConnInterface) VisionServiceClient {
return &visionServiceClient{cc}
}
func (c *visionServiceClient) BatchAnalyze(ctx context.Context, in *BatchAnalyzeRequest, opts ...grpc.CallOption) (*BatchAnalyzeResponse, error) {
out := new(BatchAnalyzeResponse)
err := c.cc.Invoke(ctx, "/yandex.cloud.ai.vision.v1.VisionService/BatchAnalyze", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
// VisionServiceServer is the server API for VisionService service.
type VisionServiceServer interface {
// Analyzes a batch of images and returns results with annotations.
BatchAnalyze(context.Context, *BatchAnalyzeRequest) (*BatchAnalyzeResponse, error)
}
// UnimplementedVisionServiceServer can be embedded to have forward compatible implementations.
type UnimplementedVisionServiceServer struct {
}
func (*UnimplementedVisionServiceServer) BatchAnalyze(ctx context.Context, req *BatchAnalyzeRequest) (*BatchAnalyzeResponse, error) {
return nil, status1.Errorf(codes.Unimplemented, "method BatchAnalyze not implemented")
}
func RegisterVisionServiceServer(s *grpc.Server, srv VisionServiceServer) {
s.RegisterService(&_VisionService_serviceDesc, srv)
}
func _VisionService_BatchAnalyze_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(BatchAnalyzeRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(VisionServiceServer).BatchAnalyze(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/yandex.cloud.ai.vision.v1.VisionService/BatchAnalyze",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(VisionServiceServer).BatchAnalyze(ctx, req.(*BatchAnalyzeRequest))
}
return interceptor(ctx, in, info, handler)
}
var _VisionService_serviceDesc = grpc.ServiceDesc{
ServiceName: "yandex.cloud.ai.vision.v1.VisionService",
HandlerType: (*VisionServiceServer)(nil),
Methods: []grpc.MethodDesc{
{
MethodName: "BatchAnalyze",
Handler: _VisionService_BatchAnalyze_Handler,
},
},
Streams: []grpc.StreamDesc{},
Metadata: "yandex/cloud/ai/vision/v1/vision_service.proto",
}

121
vendor/github.com/yandex-cloud/go-genproto/yandex/cloud/ai/vision/v1/vision_service.pbext.go generated vendored Normal file
View file

@ -0,0 +1,121 @@
// Code generated by protoc-gen-goext. DO NOT EDIT.
package vision
import (
status "google.golang.org/genproto/googleapis/rpc/status"
)
func (m *BatchAnalyzeRequest) SetAnalyzeSpecs(v []*AnalyzeSpec) {
m.AnalyzeSpecs = v
}
func (m *BatchAnalyzeRequest) SetFolderId(v string) {
m.FolderId = v
}
type AnalyzeSpec_Source = isAnalyzeSpec_Source
func (m *AnalyzeSpec) SetSource(v AnalyzeSpec_Source) {
m.Source = v
}
func (m *AnalyzeSpec) SetContent(v []byte) {
m.Source = &AnalyzeSpec_Content{
Content: v,
}
}
func (m *AnalyzeSpec) SetSignature(v string) {
m.Source = &AnalyzeSpec_Signature{
Signature: v,
}
}
func (m *AnalyzeSpec) SetFeatures(v []*Feature) {
m.Features = v
}
func (m *AnalyzeSpec) SetMimeType(v string) {
m.MimeType = v
}
type Feature_Config = isFeature_Config
func (m *Feature) SetConfig(v Feature_Config) {
m.Config = v
}
func (m *Feature) SetType(v Feature_Type) {
m.Type = v
}
func (m *Feature) SetClassificationConfig(v *FeatureClassificationConfig) {
m.Config = &Feature_ClassificationConfig{
ClassificationConfig: v,
}
}
func (m *Feature) SetTextDetectionConfig(v *FeatureTextDetectionConfig) {
m.Config = &Feature_TextDetectionConfig{
TextDetectionConfig: v,
}
}
func (m *FeatureClassificationConfig) SetModel(v string) {
m.Model = v
}
func (m *FeatureTextDetectionConfig) SetLanguageCodes(v []string) {
m.LanguageCodes = v
}
func (m *FeatureTextDetectionConfig) SetModel(v string) {
m.Model = v
}
func (m *BatchAnalyzeResponse) SetResults(v []*AnalyzeResult) {
m.Results = v
}
func (m *AnalyzeResult) SetResults(v []*FeatureResult) {
m.Results = v
}
func (m *AnalyzeResult) SetError(v *status.Status) {
m.Error = v
}
type FeatureResult_Feature = isFeatureResult_Feature
func (m *FeatureResult) SetFeature(v FeatureResult_Feature) {
m.Feature = v
}
func (m *FeatureResult) SetTextDetection(v *TextAnnotation) {
m.Feature = &FeatureResult_TextDetection{
TextDetection: v,
}
}
func (m *FeatureResult) SetClassification(v *ClassAnnotation) {
m.Feature = &FeatureResult_Classification{
Classification: v,
}
}
func (m *FeatureResult) SetFaceDetection(v *FaceAnnotation) {
m.Feature = &FeatureResult_FaceDetection{
FaceDetection: v,
}
}
func (m *FeatureResult) SetImageCopySearch(v *ImageCopySearchAnnotation) {
m.Feature = &FeatureResult_ImageCopySearch{
ImageCopySearch: v,
}
}
func (m *FeatureResult) SetError(v *status.Status) {
m.Error = v
}

4
vendor/github.com/yandex-cloud/go-genproto/yandex/cloud/api/operation.pb.go generated vendored
View file

@ -89,7 +89,9 @@ func init() {
proto.RegisterExtension(E_Operation)
}
func init() { proto.RegisterFile("yandex/cloud/api/operation.proto", fileDescriptor_6f0479639ad85daa) }
func init() {
proto.RegisterFile("yandex/cloud/api/operation.proto", fileDescriptor_6f0479639ad85daa)
}
var fileDescriptor_6f0479639ad85daa = []byte{
// 222 bytes of a gzipped FileDescriptorProto

11
vendor/github.com/yandex-cloud/go-genproto/yandex/cloud/api/operation.pbext.go generated vendored Normal file
View file

@ -0,0 +1,11 @@
// Code generated by protoc-gen-goext. DO NOT EDIT.
package api
func (m *Operation) SetMetadata(v string) {
m.Metadata = v
}
func (m *Operation) SetResponse(v string) {
m.Response = v
}

84
vendor/github.com/yandex-cloud/go-genproto/yandex/cloud/compute/v1/disk.pb.go generated vendored
View file

@ -78,6 +78,8 @@ type Disk struct {
ZoneId string `protobuf:"bytes,8,opt,name=zone_id,json=zoneId,proto3" json:"zone_id,omitempty"`
// Size of the disk, specified in bytes.
Size int64 `protobuf:"varint,9,opt,name=size,proto3" json:"size,omitempty"`
// Block size of the disk, specifiedin bytes.
BlockSize int64 `protobuf:"varint,15,opt,name=block_size,json=blockSize,proto3" json:"block_size,omitempty"`
// License IDs that indicate which licenses are attached to this resource.
// License IDs are used to calculate additional charges for the use of the virtual machine.
//
@ -188,6 +190,13 @@ func (m *Disk) GetSize() int64 {
return 0
}
func (m *Disk) GetBlockSize() int64 {
if m != nil {
return m.BlockSize
}
return 0
}
func (m *Disk) GetProductIds() []string {
if m != nil {
return m.ProductIds
@ -260,42 +269,45 @@ func init() {
proto.RegisterMapType((map[string]string)(nil), "yandex.cloud.compute.v1.Disk.LabelsEntry")
}
func init() { proto.RegisterFile("yandex/cloud/compute/v1/disk.proto", fileDescriptor_6ed05fced9465d11) }
func init() {
proto.RegisterFile("yandex/cloud/compute/v1/disk.proto", fileDescriptor_6ed05fced9465d11)
}
var fileDescriptor_6ed05fced9465d11 = []byte{
// 533 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x7c, 0x93, 0x41, 0x4f, 0xdb, 0x3e,
0x18, 0xc6, 0x49, 0xd3, 0x86, 0xe6, 0x0d, 0xf0, 0x8f, 0xac, 0xbf, 0x46, 0xc4, 0x0e, 0x64, 0x68,
0x87, 0xec, 0x40, 0x22, 0xd8, 0x65, 0x6c, 0xbb, 0x14, 0x9a, 0x6d, 0x91, 0x10, 0x9b, 0xdc, 0x72,
0xd8, 0x2e, 0x55, 0x1a, 0x9b, 0x60, 0x35, 0x8d, 0xa3, 0xd8, 0xa9, 0x56, 0x3e, 0xce, 0x3e, 0xe9,
0x64, 0x3b, 0x95, 0xb8, 0xb0, 0xdb, 0xeb, 0xe7, 0xf9, 0xd9, 0xef, 0xf3, 0x5a, 0x36, 0x9c, 0x6d,
0xf3, 0x9a, 0xd0, 0xdf, 0x49, 0x51, 0xf1, 0x8e, 0x24, 0x05, 0x5f, 0x37, 0x9d, 0xa4, 0xc9, 0xe6,
0x22, 0x21, 0x4c, 0xac, 0xe2, 0xa6, 0xe5, 0x92, 0xa3, 0x63, 0xc3, 0xc4, 0x9a, 0x89, 0x7b, 0x26,
0xde, 0x5c, 0x9c, 0x9c, 0x96, 0x9c, 0x97, 0x15, 0x4d, 0x34, 0xb6, 0xec, 0x1e, 0x12, 0xc9, 0xd6,
0x54, 0xc8, 0x7c, 0xdd, 0x98, 0x9d, 0x67, 0x7f, 0x46, 0x30, 0x9c, 0x32, 0xb1, 0x42, 0x47, 0x30,
0x60, 0x24, 0xb0, 0x42, 0x2b, 0x72, 0xf1, 0x80, 0x11, 0xf4, 0x1a, 0xdc, 0x07, 0x5e, 0x11, 0xda,
0x2e, 0x18, 0x09, 0x06, 0x5a, 0x1e, 0x1b, 0x21, 0x23, 0xe8, 0x0a, 0xa0, 0x68, 0x69, 0x2e, 0x29,
0x59, 0xe4, 0x32, 0xb0, 0x43, 0x2b, 0xf2, 0x2e, 0x4f, 0x62, 0xd3, 0x2b, 0xde, 0xf5, 0x8a, 0xe7,
0xbb, 0x5e, 0xd8, 0xed, 0xe9, 0x89, 0x44, 0x08, 0x86, 0x75, 0xbe, 0xa6, 0xc1, 0x50, 0x1f, 0xa9,
0x6b, 0x14, 0x82, 0x47, 0xa8, 0x28, 0x5a, 0xd6, 0x48, 0xc6, 0xeb, 0x60, 0xa4, 0xad, 0xe7, 0x12,
0x9a, 0x80, 0x53, 0xe5, 0x4b, 0x5a, 0x89, 0xc0, 0x09, 0xed, 0xc8, 0xbb, 0x7c, 0x17, 0xbf, 0x30,
0x71, 0xac, 0x86, 0x89, 0x6f, 0x35, 0x9b, 0xd6, 0xb2, 0xdd, 0xe2, 0x7e, 0x23, 0x3a, 0x86, 0x7d,
0xb9, 0x6d, 0xa8, 0x1a, 0x67, 0x5f, 0x37, 0x70, 0xd4, 0x32, 0x23, 0xca, 0x78, 0xe2, 0xb5, 0x36,
0xc6, 0xc6, 0x50, 0xcb, 0x8c, 0xa8, 0xa8, 0x82, 0x3d, 0xd1, 0xc0, 0x0d, 0xad, 0xc8, 0xc6, 0xba,
0x46, 0xa7, 0xe0, 0x35, 0x2d, 0x27, 0x5d, 0x21, 0x17, 0x8c, 0x88, 0x00, 0x42, 0x3b, 0x72, 0x31,
0xf4, 0x52, 0x46, 0x04, 0xfa, 0x0c, 0x8e, 0x90, 0xb9, 0xec, 0x44, 0xe0, 0x85, 0x56, 0x74, 0x74,
0xf9, 0xf6, 0xdf, 0x49, 0x67, 0x9a, 0xc5, 0xfd, 0x1e, 0x14, 0xc1, 0x7f, 0x82, 0x77, 0x6d, 0x41,
0x17, 0x6c, 0x9d, 0x97, 0x3a, 0xd3, 0x81, 0xca, 0xf4, 0x6d, 0x0f, 0x1f, 0x1a, 0x23, 0x53, 0x7a,
0x46, 0x50, 0x0c, 0xa8, 0x27, 0x45, 0x9d, 0x37, 0xe2, 0x91, 0xab, 0x40, 0xc1, 0x61, 0x0f, 0xfb,
0xc6, 0x9b, 0xf5, 0x56, 0x46, 0xd0, 0x1b, 0x38, 0x60, 0xb5, 0x90, 0x79, 0xad, 0xce, 0x26, 0x22,
0x38, 0xd2, 0xc9, 0xbd, 0x9d, 0x96, 0x11, 0x71, 0x72, 0x05, 0xde, 0xb3, 0x8b, 0x43, 0x3e, 0xd8,
0x2b, 0xba, 0xed, 0x9f, 0x84, 0x2a, 0xd1, 0xff, 0x30, 0xda, 0xe4, 0x55, 0x47, 0xfb, 0xf7, 0x60,
0x16, 0x1f, 0x07, 0x1f, 0xac, 0x33, 0x0c, 0x8e, 0x99, 0x04, 0xbd, 0x02, 0x34, 0x9b, 0x4f, 0xe6,
0xf7, 0xb3, 0xc5, 0xfd, 0xdd, 0xec, 0x47, 0x7a, 0x93, 0x7d, 0xc9, 0xd2, 0xa9, 0xbf, 0x87, 0x0e,
0x60, 0x7c, 0x83, 0xd3, 0xc9, 0x3c, 0xbb, 0xfb, 0xea, 0x5b, 0xc8, 0x85, 0x11, 0x4e, 0x27, 0xd3,
0x9f, 0xfe, 0x40, 0x95, 0x29, 0xc6, 0xdf, 0xb1, 0x6f, 0x2b, 0x66, 0x9a, 0xde, 0xa6, 0x9a, 0x19,
0x5e, 0x8f, 0xc1, 0x31, 0x53, 0x5c, 0xa7, 0xbf, 0x6e, 0x4a, 0x26, 0x1f, 0xbb, 0xa5, 0xba, 0xbe,
0xc4, 0xdc, 0xe7, 0xb9, 0xf9, 0x0f, 0x25, 0x3f, 0x2f, 0x69, 0xad, 0x9f, 0x5c, 0xf2, 0xc2, 0x47,
0xf9, 0xd4, 0x97, 0x4b, 0x47, 0x63, 0xef, 0xff, 0x06, 0x00, 0x00, 0xff, 0xff, 0x9d, 0xe9, 0x4b,
0xc4, 0x52, 0x03, 0x00, 0x00,
// 557 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x7c, 0x93, 0x4d, 0x4f, 0xdc, 0x3c,
0x14, 0x85, 0xc9, 0x7c, 0x84, 0xc9, 0x0d, 0x1f, 0x23, 0xeb, 0xd5, 0x4b, 0x04, 0xaa, 0x48, 0x51,
0x17, 0xe9, 0x82, 0x44, 0xd0, 0x4d, 0x69, 0xbb, 0x19, 0x98, 0xb4, 0x8d, 0x84, 0x68, 0xe5, 0x19,
0x16, 0xed, 0x66, 0xe4, 0x89, 0x4d, 0xb0, 0x26, 0x13, 0x47, 0xb1, 0x83, 0x3a, 0xfc, 0xbb, 0xfe,
0xb3, 0xca, 0x76, 0x90, 0xe8, 0x82, 0xee, 0xae, 0xcf, 0x79, 0xec, 0x7b, 0x8f, 0x65, 0xc3, 0xc9,
0x86, 0x54, 0x94, 0xfd, 0x4a, 0xf2, 0x52, 0xb4, 0x34, 0xc9, 0xc5, 0xba, 0x6e, 0x15, 0x4b, 0x1e,
0xce, 0x12, 0xca, 0xe5, 0x2a, 0xae, 0x1b, 0xa1, 0x04, 0x3a, 0xb0, 0x4c, 0x6c, 0x98, 0xb8, 0x63,
0xe2, 0x87, 0xb3, 0xc3, 0xe3, 0x42, 0x88, 0xa2, 0x64, 0x89, 0xc1, 0x96, 0xed, 0x5d, 0xa2, 0xf8,
0x9a, 0x49, 0x45, 0xd6, 0xb5, 0xdd, 0x79, 0xf2, 0x7b, 0x08, 0x83, 0x29, 0x97, 0x2b, 0xb4, 0x07,
0x3d, 0x4e, 0x03, 0x27, 0x74, 0x22, 0x0f, 0xf7, 0x38, 0x45, 0x47, 0xe0, 0xdd, 0x89, 0x92, 0xb2,
0x66, 0xc1, 0x69, 0xd0, 0x33, 0xf2, 0xc8, 0x0a, 0x19, 0x45, 0x17, 0x00, 0x79, 0xc3, 0x88, 0x62,
0x74, 0x41, 0x54, 0xd0, 0x0f, 0x9d, 0xc8, 0x3f, 0x3f, 0x8c, 0x6d, 0xaf, 0xf8, 0xa9, 0x57, 0x3c,
0x7f, 0xea, 0x85, 0xbd, 0x8e, 0x9e, 0x28, 0x84, 0x60, 0x50, 0x91, 0x35, 0x0b, 0x06, 0xe6, 0x48,
0x53, 0xa3, 0x10, 0x7c, 0xca, 0x64, 0xde, 0xf0, 0x5a, 0x71, 0x51, 0x05, 0x43, 0x63, 0x3d, 0x97,
0xd0, 0x04, 0xdc, 0x92, 0x2c, 0x59, 0x29, 0x03, 0x37, 0xec, 0x47, 0xfe, 0xf9, 0xdb, 0xf8, 0x85,
0xc4, 0xb1, 0x0e, 0x13, 0x5f, 0x1b, 0x36, 0xad, 0x54, 0xb3, 0xc1, 0xdd, 0x46, 0x74, 0x00, 0xdb,
0x6a, 0x53, 0x33, 0x1d, 0x67, 0xdb, 0x34, 0x70, 0xf5, 0x32, 0xa3, 0xda, 0x78, 0x14, 0x95, 0x31,
0x46, 0xd6, 0xd0, 0xcb, 0x8c, 0xea, 0x51, 0x25, 0x7f, 0x64, 0x81, 0x17, 0x3a, 0x51, 0x1f, 0x9b,
0x1a, 0xbd, 0x02, 0x58, 0x96, 0x22, 0x5f, 0x2d, 0x8c, 0xb3, 0x6f, 0x1c, 0xcf, 0x28, 0x33, 0x6d,
0x1f, 0x83, 0x5f, 0x37, 0x82, 0xb6, 0xb9, 0x5a, 0x70, 0x2a, 0x03, 0x08, 0xfb, 0x91, 0x87, 0xa1,
0x93, 0x32, 0x2a, 0xd1, 0x27, 0x70, 0xa5, 0x22, 0xaa, 0x95, 0x81, 0x1f, 0x3a, 0xd1, 0xde, 0xf9,
0x9b, 0x7f, 0x07, 0x99, 0x19, 0x16, 0x77, 0x7b, 0x50, 0x04, 0xfb, 0x52, 0xb4, 0x4d, 0xce, 0x16,
0x7c, 0x4d, 0x0a, 0x33, 0xf2, 0x8e, 0x1e, 0xf9, 0xeb, 0x16, 0xde, 0xb5, 0x46, 0xa6, 0xf5, 0x8c,
0xa2, 0x18, 0x50, 0x47, 0xca, 0x8a, 0xd4, 0xf2, 0x5e, 0xe8, 0x81, 0x82, 0xdd, 0x0e, 0x1e, 0x5b,
0x6f, 0xd6, 0x59, 0x19, 0x45, 0xaf, 0x61, 0x87, 0x57, 0x52, 0x91, 0x4a, 0x9f, 0x4d, 0x65, 0xb0,
0x67, 0x26, 0xf7, 0x9f, 0xb4, 0x8c, 0xca, 0xc3, 0x0b, 0xf0, 0x9f, 0xdd, 0x2b, 0x1a, 0x43, 0x7f,
0xc5, 0x36, 0xdd, 0x8b, 0xd1, 0x25, 0xfa, 0x0f, 0x86, 0x0f, 0xa4, 0x6c, 0x59, 0xf7, 0x5c, 0xec,
0xe2, 0x43, 0xef, 0xbd, 0x73, 0x82, 0xc1, 0xb5, 0x49, 0xd0, 0xff, 0x80, 0x66, 0xf3, 0xc9, 0xfc,
0x76, 0xb6, 0xb8, 0xbd, 0x99, 0x7d, 0x4f, 0xaf, 0xb2, 0xcf, 0x59, 0x3a, 0x1d, 0x6f, 0xa1, 0x1d,
0x18, 0x5d, 0xe1, 0x74, 0x32, 0xcf, 0x6e, 0xbe, 0x8c, 0x1d, 0xe4, 0xc1, 0x10, 0xa7, 0x93, 0xe9,
0x8f, 0x71, 0x4f, 0x97, 0x29, 0xc6, 0xdf, 0xf0, 0xb8, 0xaf, 0x99, 0x69, 0x7a, 0x9d, 0x1a, 0x66,
0x70, 0x39, 0x02, 0xd7, 0xa6, 0xb8, 0x5c, 0xc2, 0xd1, 0x5f, 0x97, 0x48, 0x6a, 0xfe, 0xec, 0x22,
0x7f, 0x5e, 0x15, 0x5c, 0xdd, 0xb7, 0x4b, 0x2d, 0x25, 0x96, 0x3b, 0xb5, 0x7f, 0xa9, 0x10, 0xa7,
0x05, 0xab, 0xcc, 0x73, 0x4d, 0x5e, 0xf8, 0x64, 0x1f, 0xbb, 0x72, 0xe9, 0x1a, 0xec, 0xdd, 0x9f,
0x00, 0x00, 0x00, 0xff, 0xff, 0x3c, 0xfe, 0x79, 0xb6, 0x8e, 0x03, 0x00, 0x00,
}

77
vendor/github.com/yandex-cloud/go-genproto/yandex/cloud/compute/v1/disk.pbext.go generated vendored Normal file
View file

@ -0,0 +1,77 @@
// Code generated by protoc-gen-goext. DO NOT EDIT.
package compute
import (
timestamp "github.com/golang/protobuf/ptypes/timestamp"
)
type Disk_Source = isDisk_Source
func (m *Disk) SetSource(v Disk_Source) {
m.Source = v
}
func (m *Disk) SetId(v string) {
m.Id = v
}
func (m *Disk) SetFolderId(v string) {
m.FolderId = v
}
func (m *Disk) SetCreatedAt(v *timestamp.Timestamp) {
m.CreatedAt = v
}
func (m *Disk) SetName(v string) {
m.Name = v
}
func (m *Disk) SetDescription(v string) {
m.Description = v
}
func (m *Disk) SetLabels(v map[string]string) {
m.Labels = v
}
func (m *Disk) SetTypeId(v string) {
m.TypeId = v
}
func (m *Disk) SetZoneId(v string) {
m.ZoneId = v
}
func (m *Disk) SetSize(v int64) {
m.Size = v
}
func (m *Disk) SetBlockSize(v int64) {
m.BlockSize = v
}
func (m *Disk) SetProductIds(v []string) {
m.ProductIds = v
}
func (m *Disk) SetStatus(v Disk_Status) {
m.Status = v
}
func (m *Disk) SetSourceImageId(v string) {
m.Source = &Disk_SourceImageId{
SourceImageId: v,
}
}
func (m *Disk) SetSourceSnapshotId(v string) {
m.Source = &Disk_SourceSnapshotId{
SourceSnapshotId: v,
}
}
func (m *Disk) SetInstanceIds(v []string) {
m.InstanceIds = v
}

167
vendor/github.com/yandex-cloud/go-genproto/yandex/cloud/compute/v1/disk_service.pb.go generated vendored
View file

@ -223,10 +223,12 @@ type CreateDiskRequest struct {
// Types that are valid to be assigned to Source:
// *CreateDiskRequest_ImageId
// *CreateDiskRequest_SnapshotId
Source isCreateDiskRequest_Source `protobuf_oneof:"source"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
Source isCreateDiskRequest_Source `protobuf_oneof:"source"`
// Block size used for disk, specified in bytes. The default is 4096.
BlockSize int64 `protobuf:"varint,10,opt,name=block_size,json=blockSize,proto3" json:"block_size,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *CreateDiskRequest) Reset() { *m = CreateDiskRequest{} }
@ -340,6 +342,13 @@ func (m *CreateDiskRequest) GetSnapshotId() string {
return ""
}
func (m *CreateDiskRequest) GetBlockSize() int64 {
if m != nil {
return m.BlockSize
}
return 0
}
// XXX_OneofWrappers is for the internal use of the proto package.
func (*CreateDiskRequest) XXX_OneofWrappers() []interface{} {
return []interface{}{
@ -731,84 +740,88 @@ func init() {
}
var fileDescriptor_7733692e1b0587d9 = []byte{
// 1084 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x56, 0x4f, 0x73, 0xdb, 0x54,
0x10, 0x47, 0xb1, 0xa2, 0xd8, 0x6b, 0x28, 0xc9, 0x83, 0x52, 0x47, 0x90, 0x99, 0x44, 0x4c, 0xd3,
0xd4, 0x45, 0x92, 0x65, 0x3b, 0xa6, 0x49, 0xdb, 0x61, 0x70, 0x13, 0x8a, 0x67, 0xda, 0x81, 0x51,
0xe1, 0x42, 0xa6, 0x93, 0x51, 0xac, 0x17, 0x57, 0x63, 0x59, 0x12, 0x7a, 0xb2, 0x27, 0x76, 0xe9,
0xa5, 0x17, 0x66, 0xc2, 0x81, 0x43, 0x87, 0x23, 0x1f, 0x80, 0xe1, 0x96, 0xe1, 0x3b, 0x38, 0xc3,
0xb1, 0x1c, 0xf8, 0x02, 0x1c, 0x38, 0xf7, 0xd8, 0x13, 0xf3, 0x9e, 0xe4, 0xff, 0x7f, 0x43, 0xe1,
0x26, 0x69, 0x7f, 0xbb, 0xfa, 0xed, 0xbe, 0xdf, 0xee, 0x3e, 0x48, 0x37, 0x0d, 0xc7, 0xc4, 0x27,
0x6a, 0xd9, 0x76, 0xeb, 0xa6, 0x5a, 0x76, 0x6b, 0x5e, 0x3d, 0xc0, 0x6a, 0x43, 0x53, 0x4d, 0x8b,
0x54, 0x0f, 0x09, 0xf6, 0x1b, 0x56, 0x19, 0x2b, 0x9e, 0xef, 0x06, 0x2e, 0xba, 0x12, 0x62, 0x15,
0x86, 0x55, 0x22, 0xac, 0xd2, 0xd0, 0xc4, 0x0f, 0x2a, 0xae, 0x5b, 0xb1, 0xb1, 0x6a, 0x78, 0x96,
0x6a, 0x38, 0x8e, 0x1b, 0x18, 0x81, 0xe5, 0x3a, 0x24, 0x74, 0x13, 0xd7, 0x23, 0x2b, 0x7b, 0x3b,
0xaa, 0x1f, 0xab, 0xc7, 0x16, 0xb6, 0xcd, 0xc3, 0x9a, 0x41, 0xaa, 0x1d, 0xc4, 0x00, 0x09, 0x1a,
0xc5, 0xf5, 0xb0, 0xcf, 0x82, 0x44, 0x08, 0x69, 0x1a, 0xcd, 0x08, 0xb3, 0x39, 0x80, 0xe9, 0x46,
0x18, 0x89, 0xb5, 0x36, 0x80, 0x6b, 0x18, 0xb6, 0x65, 0xf6, 0x99, 0xa5, 0x8f, 0xe1, 0xd2, 0x3d,
0x1c, 0xec, 0x59, 0xa4, 0xaa, 0xe3, 0x6f, 0xeb, 0x98, 0x04, 0xe8, 0x2a, 0x2c, 0xb1, 0x6a, 0x58,
0x66, 0x8a, 0x5b, 0xe7, 0xb6, 0x12, 0xc5, 0x37, 0xff, 0x6e, 0x6b, 0xdc, 0xe9, 0xb9, 0xc6, 0xdf,
0xbe, 0xb3, 0x9d, 0xd1, 0x05, 0x6a, 0x2c, 0x99, 0xd2, 0x6f, 0x1c, 0x2c, 0xdf, 0xb7, 0x08, 0x73,
0x25, 0x1d, 0xdf, 0xeb, 0x90, 0x38, 0x76, 0x6d, 0x13, 0xfb, 0x93, 0xbc, 0xe3, 0xa1, 0xb9, 0x64,
0xa2, 0x6b, 0x90, 0xf0, 0x8c, 0x0a, 0x3e, 0x24, 0x56, 0x0b, 0xa7, 0x16, 0xd6, 0xb9, 0xad, 0x58,
0x11, 0x5e, 0xb5, 0x35, 0xe1, 0xf6, 0x1d, 0x2d, 0x93, 0xc9, 0xe8, 0x71, 0x6a, 0x7c, 0x68, 0xb5,
0x30, 0xda, 0x02, 0x60, 0xc0, 0xc0, 0xad, 0x62, 0x27, 0x15, 0x63, 0x41, 0x13, 0xa7, 0xe7, 0xda,
0x22, 0x43, 0xea, 0x2c, 0xca, 0x57, 0xd4, 0x86, 0x24, 0x10, 0x8e, 0x2d, 0x3b, 0xc0, 0x7e, 0x8a,
0x67, 0x28, 0x38, 0x3d, 0xef, 0xc6, 0x8b, 0x2c, 0x92, 0x07, 0x2b, 0x7d, 0xac, 0x89, 0xe7, 0x3a,
0x04, 0xa3, 0x1c, 0x2c, 0xd2, 0xac, 0x48, 0x8a, 0x5b, 0x8f, 0x6d, 0x25, 0xb3, 0x6b, 0xca, 0x84,
0xa3, 0x57, 0x58, 0x9d, 0x42, 0x2c, 0xda, 0x84, 0xb7, 0x1d, 0x7c, 0x12, 0x1c, 0xf6, 0x91, 0xa3,
0x69, 0x24, 0xf4, 0xb7, 0xe8, 0xe7, 0x2f, 0x3b, 0xac, 0xa4, 0xdf, 0x79, 0x58, 0xb9, 0xeb, 0x63,
0x23, 0xc0, 0xfd, 0x55, 0xbe, 0x40, 0xa5, 0xb6, 0x81, 0x77, 0x8c, 0x5a, 0x58, 0xa4, 0x44, 0x71,
0xe3, 0x65, 0x5b, 0x5b, 0xfb, 0xee, 0xc0, 0x90, 0x5b, 0x8f, 0x0e, 0x64, 0x43, 0x6e, 0x65, 0xe4,
0x9d, 0x47, 0x4f, 0xb4, 0x8f, 0x0a, 0xda, 0xd3, 0x83, 0xe8, 0x4d, 0x67, 0x70, 0x74, 0x03, 0x92,
0x26, 0x26, 0x65, 0xdf, 0xf2, 0xe8, 0x71, 0x0f, 0x16, 0x2e, 0xbb, 0x5d, 0xd0, 0xfb, 0xad, 0xe8,
0x47, 0x0e, 0x04, 0xdb, 0x38, 0xc2, 0x36, 0x49, 0xf1, 0xac, 0x06, 0x85, 0x89, 0x35, 0x18, 0xc9,
0x45, 0xb9, 0xcf, 0x1c, 0xf7, 0x9d, 0xc0, 0x6f, 0x16, 0x3f, 0x79, 0xd9, 0xd6, 0x92, 0x07, 0xf2,
0x61, 0x46, 0xde, 0xa1, 0x14, 0xd3, 0xcf, 0x58, 0x3e, 0x85, 0x7c, 0x98, 0x57, 0x21, 0x77, 0x76,
0xae, 0x09, 0x22, 0xaf, 0xc9, 0xec, 0x09, 0xa1, 0xe5, 0x28, 0x91, 0x2e, 0x5e, 0x8f, 0x68, 0xa0,
0x0d, 0x58, 0x0a, 0x9a, 0x1e, 0xa6, 0xe5, 0x59, 0x64, 0xd4, 0xe3, 0x3d, 0x09, 0x52, 0x43, 0xc9,
0xa4, 0x4a, 0x6d, 0xb9, 0x0e, 0x83, 0x08, 0xe3, 0x94, 0x4a, 0x8d, 0x25, 0x13, 0x69, 0xc0, 0x33,
0x91, 0x2d, 0x31, 0x91, 0xad, 0x51, 0xcc, 0xab, 0xb6, 0x76, 0x39, 0xaf, 0xed, 0xe4, 0x73, 0x99,
0xbc, 0x9c, 0xcf, 0xed, 0xdc, 0xcc, 0xe4, 0x0b, 0xdb, 0x9a, 0xa6, 0x65, 0xf2, 0x3a, 0x83, 0xa2,
0xab, 0x10, 0xb7, 0x6a, 0xf4, 0x5c, 0x2d, 0x33, 0x15, 0x1f, 0xfc, 0xfb, 0xe7, 0x6f, 0xe8, 0x4b,
0xcc, 0x56, 0x32, 0x69, 0x89, 0x89, 0x63, 0x78, 0xe4, 0xb1, 0x1b, 0x50, 0x64, 0x62, 0x04, 0x09,
0x1d, 0x73, 0xc9, 0x14, 0x77, 0x20, 0xd9, 0x57, 0x28, 0xb4, 0x0c, 0xb1, 0x2a, 0x6e, 0x86, 0x47,
0xaf, 0xd3, 0x47, 0xf4, 0x2e, 0x2c, 0x36, 0x0c, 0xbb, 0x1e, 0x1d, 0xb4, 0x1e, 0xbe, 0xec, 0x2e,
0xdc, 0xe4, 0x8a, 0x71, 0x10, 0x88, 0x5b, 0xf7, 0xcb, 0x58, 0x92, 0x01, 0xf5, 0xea, 0xff, 0x00,
0x07, 0x86, 0x69, 0x04, 0x06, 0xba, 0x32, 0xd4, 0xb2, 0xdd, 0x26, 0xfd, 0x33, 0x06, 0x2b, 0x5f,
0x7b, 0xe6, 0x90, 0xf6, 0xe6, 0xeb, 0x70, 0x74, 0x0b, 0x92, 0x75, 0xe6, 0xcb, 0x86, 0x17, 0x63,
0x95, 0xcc, 0x8a, 0x4a, 0x38, 0xdf, 0x94, 0xce, 0x7c, 0x53, 0x3e, 0xa3, 0xf3, 0xed, 0x81, 0x41,
0xaa, 0x3a, 0x84, 0x70, 0xfa, 0xdc, 0x15, 0x6d, 0xec, 0xb5, 0x44, 0xcb, 0xcf, 0x2b, 0xda, 0xc5,
0x19, 0xa2, 0x1d, 0x29, 0xc2, 0xff, 0x23, 0x5a, 0x39, 0x92, 0x9a, 0xc0, 0xa4, 0xb6, 0x3a, 0x43,
0x66, 0xaf, 0x21, 0x09, 0x2a, 0x84, 0x5e, 0x4e, 0xb3, 0x85, 0xb0, 0x0b, 0x2b, 0x7b, 0xd8, 0xc6,
0xff, 0x46, 0x07, 0xf4, 0x57, 0x3d, 0xdf, 0xd9, 0xbf, 0xfa, 0x89, 0x83, 0xd5, 0xce, 0x88, 0xfd,
0xa2, 0xb3, 0x8c, 0xc8, 0x05, 0xb5, 0xf7, 0xdf, 0x6f, 0x07, 0xe9, 0x7b, 0x0e, 0xc4, 0x71, 0xbc,
0xa2, 0x1d, 0xf0, 0x29, 0x40, 0x77, 0x75, 0x76, 0x16, 0xc1, 0xc6, 0xa0, 0x9e, 0x7a, 0xab, 0xb5,
0xeb, 0xaf, 0xf7, 0x39, 0xcd, 0xbb, 0x11, 0xb2, 0x3f, 0x2c, 0x41, 0x92, 0xb2, 0x78, 0x18, 0xde,
0x37, 0x90, 0x0f, 0xb1, 0x7b, 0x38, 0x40, 0xd7, 0x26, 0xaa, 0x77, 0x70, 0x43, 0x8b, 0xd3, 0xf7,
0x93, 0xf4, 0xe1, 0xb3, 0x3f, 0xfe, 0x7a, 0xbe, 0xb0, 0x86, 0xde, 0x1f, 0xbe, 0x39, 0x10, 0xf5,
0x49, 0x54, 0xfb, 0xa7, 0xe8, 0x04, 0x78, 0x5a, 0x0c, 0x74, 0x7d, 0x62, 0xac, 0xe1, 0xe5, 0x2e,
0xa6, 0xe7, 0x81, 0x86, 0xd5, 0x94, 0x56, 0x19, 0x87, 0x77, 0xd0, 0xca, 0x08, 0x07, 0xf4, 0x9c,
0x03, 0x21, 0x9c, 0x61, 0x28, 0x3d, 0xff, 0x92, 0x11, 0x67, 0x9f, 0x85, 0xb4, 0x7b, 0xf6, 0x22,
0x2d, 0x8e, 0x1d, 0x90, 0x3c, 0x7d, 0x63, 0x94, 0xde, 0x93, 0x46, 0x29, 0xed, 0x72, 0x69, 0xf4,
0x33, 0x07, 0x42, 0xd8, 0x50, 0x53, 0x58, 0x8d, 0x4c, 0x91, 0x79, 0x58, 0xed, 0x85, 0xac, 0xc6,
0x74, 0x6b, 0x8f, 0xd5, 0x7a, 0x76, 0xda, 0x61, 0x51, 0x7e, 0xbf, 0x72, 0x20, 0x84, 0x5d, 0x38,
0x85, 0xdf, 0x48, 0x8b, 0xcf, 0xc3, 0x4f, 0x3f, 0x7b, 0x91, 0xbe, 0x31, 0xb6, 0xc5, 0x2f, 0x0f,
0x8f, 0xfa, 0xfd, 0x9a, 0x17, 0x34, 0x43, 0x75, 0xa5, 0xa7, 0xaa, 0xeb, 0x17, 0x0e, 0x2e, 0x51,
0x51, 0xf4, 0xfa, 0x0c, 0x65, 0x67, 0xaa, 0x67, 0x64, 0x58, 0x88, 0xb9, 0x0b, 0xf9, 0x44, 0xd2,
0x53, 0x18, 0xc1, 0x2d, 0xb4, 0x39, 0x85, 0x60, 0xef, 0x96, 0x4c, 0x8a, 0xfb, 0xdf, 0xdc, 0xad,
0x58, 0xc1, 0xe3, 0xfa, 0x11, 0x8d, 0xaf, 0x86, 0x3f, 0x94, 0xc3, 0xdb, 0x72, 0xc5, 0x95, 0x2b,
0xd8, 0x61, 0xe9, 0xab, 0x13, 0xae, 0xe4, 0xb7, 0xa2, 0xc7, 0x23, 0x81, 0xc1, 0x72, 0xff, 0x04,
0x00, 0x00, 0xff, 0xff, 0x53, 0xd3, 0x66, 0xe5, 0x63, 0x0c, 0x00, 0x00,
// 1138 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x56, 0x4f, 0x6f, 0x1b, 0xc5,
0x1b, 0xfe, 0x6d, 0xed, 0x6c, 0xec, 0xd7, 0x3f, 0xda, 0x66, 0x68, 0x53, 0x67, 0x4b, 0x90, 0xbb,
0xd0, 0xd4, 0x71, 0xd9, 0xbf, 0x76, 0x9c, 0x3f, 0x6d, 0x05, 0xb8, 0x29, 0xc1, 0x52, 0x2b, 0xd0,
0x16, 0x2e, 0x84, 0x2a, 0x5a, 0x7b, 0x27, 0xee, 0xca, 0x9b, 0xdd, 0xc5, 0xbb, 0x8e, 0x92, 0x94,
0x5e, 0x7a, 0x41, 0x0a, 0xc7, 0x0a, 0x71, 0xe2, 0x03, 0x20, 0x6e, 0x11, 0xdf, 0xc1, 0x39, 0x97,
0x6f, 0x80, 0x38, 0x70, 0xae, 0xc4, 0x25, 0x27, 0x34, 0x33, 0xeb, 0xff, 0xb1, 0xe3, 0x50, 0xb8,
0xed, 0xec, 0xfb, 0xbc, 0x33, 0xcf, 0x3c, 0xf3, 0xcc, 0xfb, 0x0e, 0xe4, 0xf6, 0x4d, 0xd7, 0xc2,
0x7b, 0x4a, 0xd5, 0xf1, 0x9a, 0x96, 0x52, 0xf5, 0x76, 0xfc, 0x66, 0x88, 0x95, 0x5d, 0x4d, 0xb1,
0xec, 0xa0, 0xbe, 0x15, 0xe0, 0xc6, 0xae, 0x5d, 0xc5, 0xb2, 0xdf, 0xf0, 0x42, 0x0f, 0x5d, 0x63,
0x58, 0x99, 0x62, 0xe5, 0x08, 0x2b, 0xef, 0x6a, 0xc2, 0x3b, 0x35, 0xcf, 0xab, 0x39, 0x58, 0x31,
0x7d, 0x5b, 0x31, 0x5d, 0xd7, 0x0b, 0xcd, 0xd0, 0xf6, 0xdc, 0x80, 0xa5, 0x09, 0x99, 0x28, 0x4a,
0x47, 0x95, 0xe6, 0xb6, 0xb2, 0x6d, 0x63, 0xc7, 0xda, 0xda, 0x31, 0x83, 0x7a, 0x1b, 0xd1, 0x47,
0x82, 0xcc, 0xe2, 0xf9, 0xb8, 0x41, 0x27, 0x89, 0x10, 0xe2, 0x38, 0x9a, 0x11, 0x66, 0xa1, 0x0f,
0xd3, 0x99, 0x61, 0x68, 0xae, 0xf9, 0x3e, 0xdc, 0xae, 0xe9, 0xd8, 0x56, 0x4f, 0x58, 0x5c, 0x86,
0x8b, 0x1b, 0x38, 0x5c, 0xb7, 0x83, 0xba, 0x81, 0xbf, 0x69, 0xe2, 0x20, 0x44, 0x37, 0x61, 0x9a,
0xaa, 0x61, 0x5b, 0x69, 0x2e, 0xc3, 0x65, 0x93, 0xa5, 0xff, 0xff, 0xd9, 0xd2, 0xb8, 0xc3, 0x63,
0x2d, 0x7e, 0xf7, 0xde, 0x92, 0x6a, 0xf0, 0x24, 0x58, 0xb6, 0xc4, 0x5f, 0x39, 0xb8, 0xfc, 0xd0,
0x0e, 0x68, 0x6a, 0xd0, 0xce, 0x5d, 0x84, 0xe4, 0xb6, 0xe7, 0x58, 0xb8, 0x31, 0x2a, 0x3b, 0xc1,
0xc2, 0x65, 0x0b, 0xdd, 0x82, 0xa4, 0x6f, 0xd6, 0xf0, 0x56, 0x60, 0x1f, 0xe0, 0xf4, 0x85, 0x0c,
0x97, 0x8d, 0x95, 0xe0, 0xa4, 0xa5, 0xf1, 0x77, 0xef, 0x69, 0xaa, 0xaa, 0x1a, 0x09, 0x12, 0x7c,
0x6c, 0x1f, 0x60, 0x94, 0x05, 0xa0, 0xc0, 0xd0, 0xab, 0x63, 0x37, 0x1d, 0xa3, 0x93, 0x26, 0x0f,
0x8f, 0xb5, 0x29, 0x8a, 0x34, 0xe8, 0x2c, 0x5f, 0x90, 0x18, 0x12, 0x81, 0xdf, 0xb6, 0x9d, 0x10,
0x37, 0xd2, 0x71, 0x8a, 0x82, 0xc3, 0xe3, 0xce, 0x7c, 0x51, 0x44, 0xf4, 0x61, 0xa6, 0x87, 0x75,
0xe0, 0x7b, 0x6e, 0x80, 0x51, 0x1e, 0xa6, 0xc8, 0xae, 0x82, 0x34, 0x97, 0x89, 0x65, 0x53, 0xfa,
0xbc, 0x3c, 0xe2, 0xe8, 0x65, 0xaa, 0x13, 0xc3, 0xa2, 0x05, 0xb8, 0xe4, 0xe2, 0xbd, 0x70, 0xab,
0x87, 0x1c, 0xd9, 0x46, 0xd2, 0x78, 0x8b, 0xfc, 0xfe, 0xbc, 0xcd, 0x4a, 0xfc, 0x2b, 0x0e, 0x33,
0xf7, 0x1b, 0xd8, 0x0c, 0x71, 0xaf, 0xca, 0xe7, 0x50, 0x6a, 0x05, 0xe2, 0xae, 0xb9, 0xc3, 0x44,
0x4a, 0x96, 0xde, 0x7f, 0xdd, 0xd2, 0x32, 0xdf, 0x6e, 0x9a, 0xd2, 0xc1, 0x93, 0xec, 0xa6, 0x64,
0x4a, 0x07, 0xaa, 0xb4, 0xfa, 0xe4, 0x99, 0xfa, 0x41, 0x51, 0x7b, 0xbe, 0x19, 0x8d, 0x16, 0x3f,
0x34, 0x68, 0x06, 0xba, 0x0d, 0x29, 0x0b, 0x07, 0xd5, 0x86, 0xed, 0x93, 0x13, 0xef, 0xd7, 0x4e,
0x5f, 0x2a, 0x1a, 0xbd, 0x51, 0xf4, 0x23, 0x07, 0xbc, 0x63, 0x56, 0xb0, 0x13, 0xa4, 0xe3, 0x54,
0x86, 0xe2, 0x48, 0x19, 0x86, 0xb6, 0x23, 0x3f, 0xa4, 0x89, 0x0f, 0xdc, 0xb0, 0xb1, 0x5f, 0xda,
0x78, 0xdd, 0xd2, 0x2e, 0x6d, 0x4a, 0x5b, 0xb2, 0xf2, 0xf5, 0x47, 0xaa, 0xb4, 0x4a, 0x98, 0xe6,
0x5e, 0xd0, 0x6d, 0x15, 0x0b, 0x6c, 0x7b, 0xc5, 0xfc, 0xd1, 0xb1, 0xc6, 0x0b, 0x71, 0x4d, 0xa2,
0x5f, 0xb3, 0xe8, 0x0a, 0xdd, 0xcf, 0x40, 0x8e, 0x11, 0xd1, 0x41, 0x37, 0x60, 0x3a, 0xdc, 0xf7,
0x31, 0x51, 0x6a, 0x8a, 0x6e, 0x21, 0xd1, 0x75, 0x23, 0x09, 0x94, 0x2d, 0x62, 0xda, 0x03, 0xcf,
0xa5, 0x10, 0xfe, 0x34, 0xd3, 0x92, 0x60, 0xd9, 0x42, 0x3a, 0xc4, 0xa9, 0xdf, 0xa6, 0xa9, 0xdf,
0xde, 0x25, 0x98, 0x93, 0x96, 0x36, 0x5b, 0xd0, 0x56, 0x0b, 0x79, 0xb5, 0x20, 0xe9, 0x2b, 0x4b,
0x2b, 0xcb, 0x79, 0x55, 0xcf, 0xeb, 0xba, 0xb6, 0x5c, 0x34, 0x28, 0x16, 0xdd, 0x84, 0x84, 0xbd,
0x43, 0xce, 0xd8, 0xb6, 0xd2, 0x89, 0xfe, 0xe5, 0x3f, 0xfd, 0x9f, 0x31, 0x4d, 0x63, 0x65, 0x8b,
0x68, 0x1d, 0xb8, 0xa6, 0x1f, 0x3c, 0xf5, 0x42, 0x82, 0x4c, 0x0e, 0x21, 0xa1, 0x1d, 0x2e, 0x5b,
0x68, 0x1e, 0xa0, 0xe2, 0x78, 0xd5, 0x3a, 0x73, 0x3f, 0x10, 0x36, 0x46, 0x92, 0xfe, 0x21, 0x96,
0x17, 0x56, 0x21, 0xd5, 0x23, 0x28, 0xba, 0x0c, 0xb1, 0x3a, 0xde, 0x67, 0x2e, 0x31, 0xc8, 0x27,
0xba, 0x02, 0x53, 0xbb, 0xa6, 0xd3, 0x8c, 0x3c, 0x61, 0xb0, 0xc1, 0xda, 0x85, 0x15, 0xae, 0x94,
0x00, 0x3e, 0xf0, 0x9a, 0x8d, 0x2a, 0x16, 0x25, 0x40, 0xdd, 0x73, 0x7a, 0x84, 0x43, 0xd3, 0x32,
0x43, 0x13, 0x5d, 0x1b, 0xb8, 0xdd, 0x9d, 0xfb, 0xfc, 0x7b, 0x0c, 0x66, 0xbe, 0xf4, 0xad, 0x01,
0x9b, 0x4e, 0x56, 0x0c, 0xd0, 0x1d, 0x48, 0x35, 0x69, 0x2e, 0xad, 0x73, 0x94, 0x55, 0x4a, 0x17,
0x64, 0x56, 0x0a, 0xe5, 0x76, 0x29, 0x94, 0x3f, 0x21, 0xa5, 0xf0, 0x91, 0x19, 0xd4, 0x0d, 0x60,
0x70, 0xf2, 0xdd, 0xf1, 0x77, 0xec, 0x4d, 0xfd, 0x1d, 0x9f, 0xd4, 0xdf, 0x53, 0x67, 0xf8, 0x7b,
0x48, 0x87, 0xff, 0xd6, 0xdf, 0x52, 0xe4, 0x4a, 0x9e, 0xba, 0x72, 0xee, 0xa4, 0xa5, 0x5d, 0x6d,
0x3b, 0xb2, 0x90, 0x5f, 0x5d, 0x51, 0x0b, 0xc5, 0x25, 0x4d, 0xd3, 0xd4, 0x02, 0x33, 0xe4, 0x1b,
0xb8, 0x83, 0x78, 0xa2, 0xbb, 0xb7, 0xb3, 0x3d, 0xb1, 0x06, 0x33, 0xeb, 0xd8, 0xc1, 0xff, 0xc4,
0x12, 0x64, 0xa9, 0x6e, 0xee, 0xd9, 0x4b, 0xfd, 0xc0, 0xc1, 0x5c, 0xbb, 0x30, 0x7f, 0xd6, 0x6e,
0x61, 0xc1, 0x39, 0x6d, 0xf8, 0xef, 0xf7, 0x14, 0xf1, 0x3b, 0x0e, 0x84, 0xd3, 0x78, 0x45, 0x9d,
0xe3, 0x63, 0x80, 0x4e, 0xc3, 0x6d, 0xb7, 0x8f, 0x1b, 0xfd, 0xbe, 0xea, 0x36, 0xe4, 0x4e, 0xbe,
0xd1, 0x93, 0x34, 0x69, 0x1f, 0xd1, 0xbf, 0x9f, 0x86, 0x14, 0x61, 0xf1, 0x98, 0xbd, 0x52, 0x50,
0x03, 0x62, 0x1b, 0x38, 0x44, 0xb7, 0x46, 0xba, 0xb8, 0xbf, 0xaf, 0x0b, 0xe3, 0xbb, 0x9a, 0xf8,
0xde, 0x8b, 0xdf, 0xfe, 0x78, 0x79, 0x61, 0x1e, 0x5d, 0x1f, 0x7c, 0x6f, 0x04, 0xca, 0xb3, 0x48,
0xfb, 0xe7, 0x68, 0x0f, 0xe2, 0x44, 0x0c, 0xb4, 0x38, 0x72, 0xae, 0xc1, 0x27, 0x81, 0x90, 0x9b,
0x04, 0xca, 0xd4, 0x14, 0xe7, 0x28, 0x87, 0xb7, 0xd1, 0xcc, 0x10, 0x07, 0xf4, 0x92, 0x03, 0x9e,
0x95, 0x33, 0x94, 0x9b, 0xbc, 0x2f, 0x09, 0x67, 0x9f, 0x85, 0xb8, 0x76, 0xf4, 0x2a, 0x27, 0x9c,
0x5a, 0x2b, 0xe3, 0x64, 0x44, 0x29, 0xcd, 0x8a, 0xc3, 0x94, 0xd6, 0xb8, 0x1c, 0xfa, 0x89, 0x03,
0x9e, 0x5d, 0xa8, 0x31, 0xac, 0x86, 0xaa, 0xc9, 0x24, 0xac, 0xd6, 0x19, 0xab, 0x53, 0x6e, 0x6b,
0x97, 0x55, 0x46, 0x1f, 0x77, 0x58, 0x84, 0xdf, 0x2f, 0x1c, 0xf0, 0xec, 0x16, 0x8e, 0xe1, 0x37,
0x74, 0xc5, 0x27, 0xe1, 0x67, 0x1c, 0xbd, 0xca, 0xdd, 0x3e, 0xf5, 0x8a, 0x5f, 0x1d, 0xac, 0xfa,
0x0f, 0x76, 0xfc, 0x70, 0x9f, 0xb9, 0x2b, 0x37, 0xd6, 0x5d, 0x3f, 0x73, 0x70, 0x91, 0x98, 0xa2,
0x7b, 0xcf, 0x90, 0x7e, 0xa6, 0x7b, 0x86, 0x8a, 0x85, 0x90, 0x3f, 0x57, 0x4e, 0x64, 0x3d, 0x99,
0x12, 0xcc, 0xa2, 0x85, 0x31, 0x04, 0xbb, 0x6f, 0xeb, 0xa0, 0x54, 0x81, 0xeb, 0x7d, 0xab, 0x98,
0xbe, 0xdd, 0xb3, 0xd2, 0x57, 0xf7, 0x6b, 0x76, 0xf8, 0xb4, 0x59, 0x21, 0xbf, 0x14, 0x86, 0x93,
0xd8, 0x03, 0xbc, 0xe6, 0x49, 0x35, 0xec, 0x52, 0x6d, 0x94, 0x11, 0xaf, 0xfc, 0x3b, 0xd1, 0x67,
0x85, 0xa7, 0xb0, 0xfc, 0xdf, 0x01, 0x00, 0x00, 0xff, 0xff, 0x7a, 0xdc, 0x3b, 0x4b, 0xb6, 0x0c,
0x00, 0x00,
}
// Reference imports to suppress errors if they are not otherwise used.
var _ context.Context
var _ grpc.ClientConn
var _ grpc.ClientConnInterface
// This is a compile-time assertion to ensure that this generated file
// is compatible with the grpc package it is being compiled against.
const _ = grpc.SupportPackageIsVersion4
const _ = grpc.SupportPackageIsVersion6
// DiskServiceClient is the client API for DiskService service.
//
@ -839,10 +852,10 @@ type DiskServiceClient interface {
}
type diskServiceClient struct {
cc *grpc.ClientConn
cc grpc.ClientConnInterface
}
func NewDiskServiceClient(cc *grpc.ClientConn) DiskServiceClient {
func NewDiskServiceClient(cc grpc.ClientConnInterface) DiskServiceClient {
return &diskServiceClient{cc}
}

146
vendor/github.com/yandex-cloud/go-genproto/yandex/cloud/compute/v1/disk_service.pbext.go generated vendored Normal file
View file

@ -0,0 +1,146 @@
// Code generated by protoc-gen-goext. DO NOT EDIT.
package compute
import (
operation "github.com/yandex-cloud/go-genproto/yandex/cloud/operation"
field_mask "google.golang.org/genproto/protobuf/field_mask"
)
func (m *GetDiskRequest) SetDiskId(v string) {
m.DiskId = v
}
func (m *ListDisksRequest) SetFolderId(v string) {
m.FolderId = v
}
func (m *ListDisksRequest) SetPageSize(v int64) {
m.PageSize = v
}
func (m *ListDisksRequest) SetPageToken(v string) {
m.PageToken = v
}
func (m *ListDisksRequest) SetFilter(v string) {
m.Filter = v
}
func (m *ListDisksResponse) SetDisks(v []*Disk) {
m.Disks = v
}
func (m *ListDisksResponse) SetNextPageToken(v string) {
m.NextPageToken = v
}
type CreateDiskRequest_Source = isCreateDiskRequest_Source
func (m *CreateDiskRequest) SetSource(v CreateDiskRequest_Source) {
m.Source = v
}
func (m *CreateDiskRequest) SetFolderId(v string) {
m.FolderId = v
}
func (m *CreateDiskRequest) SetName(v string) {
m.Name = v
}
func (m *CreateDiskRequest) SetDescription(v string) {
m.Description = v
}
func (m *CreateDiskRequest) SetLabels(v map[string]string) {
m.Labels = v
}
func (m *CreateDiskRequest) SetTypeId(v string) {
m.TypeId = v
}
func (m *CreateDiskRequest) SetZoneId(v string) {
m.ZoneId = v
}
func (m *CreateDiskRequest) SetSize(v int64) {
m.Size = v
}
func (m *CreateDiskRequest) SetImageId(v string) {
m.Source = &CreateDiskRequest_ImageId{
ImageId: v,
}
}
func (m *CreateDiskRequest) SetSnapshotId(v string) {
m.Source = &CreateDiskRequest_SnapshotId{
SnapshotId: v,
}
}
func (m *CreateDiskRequest) SetBlockSize(v int64) {
m.BlockSize = v
}
func (m *CreateDiskMetadata) SetDiskId(v string) {
m.DiskId = v
}
func (m *UpdateDiskRequest) SetDiskId(v string) {
m.DiskId = v
}
func (m *UpdateDiskRequest) SetUpdateMask(v *field_mask.FieldMask) {
m.UpdateMask = v
}
func (m *UpdateDiskRequest) SetName(v string) {
m.Name = v
}
func (m *UpdateDiskRequest) SetDescription(v string) {
m.Description = v
}
func (m *UpdateDiskRequest) SetLabels(v map[string]string) {
m.Labels = v
}
func (m *UpdateDiskRequest) SetSize(v int64) {
m.Size = v
}
func (m *UpdateDiskMetadata) SetDiskId(v string) {
m.DiskId = v
}
func (m *DeleteDiskRequest) SetDiskId(v string) {
m.DiskId = v
}
func (m *DeleteDiskMetadata) SetDiskId(v string) {
m.DiskId = v
}
func (m *ListDiskOperationsRequest) SetDiskId(v string) {
m.DiskId = v
}
func (m *ListDiskOperationsRequest) SetPageSize(v int64) {
m.PageSize = v
}
func (m *ListDiskOperationsRequest) SetPageToken(v string) {
m.PageToken = v
}
func (m *ListDiskOperationsResponse) SetOperations(v []*operation.Operation) {
m.Operations = v
}
func (m *ListDiskOperationsResponse) SetNextPageToken(v string) {
m.NextPageToken = v
}

11
vendor/github.com/yandex-cloud/go-genproto/yandex/cloud/compute/v1/disk_type.pb.go generated vendored
View file

@ -87,7 +87,7 @@ func init() {
}
var fileDescriptor_1766b4de885b3ba4 = []byte{
// 190 bytes of a gzipped FileDescriptorProto
// 199 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x52, 0xaf, 0x4c, 0xcc, 0x4b,
0x49, 0xad, 0xd0, 0x4f, 0xce, 0xc9, 0x2f, 0x4d, 0xd1, 0x4f, 0xce, 0xcf, 0x2d, 0x28, 0x2d, 0x49,
0xd5, 0x2f, 0x33, 0xd4, 0x4f, 0xc9, 0x2c, 0xce, 0x8e, 0x2f, 0xa9, 0x2c, 0x48, 0xd5, 0x2b, 0x28,
@ -96,8 +96,9 @@ var fileDescriptor_1766b4de885b3ba4 = []byte{
0xca, 0x4c, 0x91, 0x60, 0x54, 0x60, 0xd4, 0xe0, 0x0c, 0x62, 0xca, 0x4c, 0x11, 0x52, 0xe0, 0xe2,
0x4e, 0x49, 0x2d, 0x4e, 0x2e, 0xca, 0x2c, 0x28, 0xc9, 0xcc, 0xcf, 0x93, 0x60, 0x02, 0x4b, 0x20,
0x0b, 0x09, 0x49, 0x72, 0x71, 0x54, 0xe5, 0xe7, 0xa5, 0xc6, 0x67, 0xa6, 0x14, 0x4b, 0x30, 0x2b,
0x30, 0x6b, 0x70, 0x06, 0xb1, 0x83, 0xf8, 0x9e, 0x29, 0xc5, 0x4e, 0xae, 0x51, 0xce, 0xe9, 0x99,
0x25, 0x19, 0xa5, 0x49, 0x20, 0xdb, 0xf4, 0x21, 0xd6, 0xeb, 0x42, 0xdc, 0x99, 0x9e, 0xaf, 0x9b,
0x9e, 0x9a, 0x07, 0x76, 0x98, 0x3e, 0x0e, 0x0f, 0x58, 0x43, 0x99, 0x49, 0x6c, 0x60, 0x65, 0xc6,
0x80, 0x00, 0x00, 0x00, 0xff, 0xff, 0x42, 0x85, 0x4f, 0x91, 0xea, 0x00, 0x00, 0x00,
0x30, 0x6b, 0x70, 0x06, 0xb1, 0x83, 0xf8, 0x9e, 0x29, 0xc5, 0x4e, 0x49, 0x5c, 0xd2, 0x28, 0x76,
0x26, 0x16, 0x64, 0x22, 0xd9, 0x1b, 0xe5, 0x9c, 0x9e, 0x59, 0x92, 0x51, 0x9a, 0x04, 0x12, 0xd2,
0x87, 0xa8, 0xd3, 0x85, 0x78, 0x22, 0x3d, 0x5f, 0x37, 0x3d, 0x35, 0x0f, 0xec, 0x6a, 0x7d, 0x1c,
0xbe, 0xb3, 0x86, 0x32, 0x93, 0xd8, 0xc0, 0xca, 0x8c, 0x01, 0x01, 0x00, 0x00, 0xff, 0xff, 0x20,
0xf6, 0x52, 0x89, 0x07, 0x01, 0x00, 0x00,
}

15
vendor/github.com/yandex-cloud/go-genproto/yandex/cloud/compute/v1/disk_type.pbext.go generated vendored Normal file
View file

@ -0,0 +1,15 @@
// Code generated by protoc-gen-goext. DO NOT EDIT.
package compute
func (m *DiskType) SetId(v string) {
m.Id = v
}
func (m *DiskType) SetDescription(v string) {
m.Description = v
}
func (m *DiskType) SetZoneIds(v []string) {
m.ZoneIds = v
}

65
vendor/github.com/yandex-cloud/go-genproto/yandex/cloud/compute/v1/disk_type_service.pb.go generated vendored
View file

@ -185,43 +185,44 @@ func init() {
}
var fileDescriptor_0433b2f525f69d83 = []byte{
// 427 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x8c, 0x93, 0xcf, 0xaa, 0xd3, 0x40,
0x14, 0xc6, 0x49, 0x7b, 0xbd, 0x98, 0xa3, 0x72, 0x61, 0xf0, 0x72, 0x4b, 0xf0, 0xc2, 0x35, 0x48,
0x5b, 0xd0, 0x66, 0x9a, 0xba, 0xb4, 0x82, 0x54, 0xa5, 0x08, 0x2e, 0x24, 0xed, 0xca, 0x4d, 0x48,
0x9b, 0x43, 0x1c, 0x5a, 0x67, 0x62, 0x67, 0x12, 0xda, 0x8a, 0x0b, 0xff, 0xac, 0xdc, 0xba, 0xf7,
0x75, 0xea, 0xde, 0x57, 0x70, 0xe1, 0x33, 0xb8, 0x92, 0x4c, 0x92, 0xaa, 0xb5, 0xa1, 0x77, 0x17,
0x72, 0xbe, 0xef, 0x9c, 0xdf, 0x9c, 0x6f, 0x06, 0xe8, 0x2a, 0xe0, 0x21, 0x2e, 0xe9, 0x74, 0x2e,
0x92, 0x90, 0x4e, 0xc5, 0xeb, 0x38, 0x51, 0x48, 0x53, 0x97, 0x86, 0x4c, 0xce, 0x7c, 0xb5, 0x8a,
0xd1, 0x97, 0xb8, 0x48, 0xd9, 0x14, 0x9d, 0x78, 0x21, 0x94, 0x20, 0x67, 0xb9, 0xc1, 0xd1, 0x06,
0xa7, 0x30, 0x38, 0xa9, 0x6b, 0xdd, 0x8a, 0x84, 0x88, 0xe6, 0x48, 0x83, 0x98, 0xd1, 0x80, 0x73,
0xa1, 0x02, 0xc5, 0x04, 0x97, 0xb9, 0xcd, 0x6a, 0x1d, 0x9c, 0x53, 0x08, 0xcf, 0xff, 0x11, 0xa6,
0xc1, 0x9c, 0x85, 0xba, 0x51, 0x5e, 0xb6, 0xfb, 0x40, 0x86, 0xa8, 0x9e, 0x30, 0x39, 0x1b, 0xaf,
0x62, 0xf4, 0xf0, 0x4d, 0x82, 0x52, 0x91, 0x26, 0x5c, 0xff, 0xc3, 0xcb, 0xc2, 0x86, 0x71, 0x61,
0xb4, 0xcd, 0xc1, 0xd1, 0xcf, 0x8d, 0x6b, 0x78, 0x10, 0x16, 0xe2, 0x67, 0xa1, 0xcd, 0xe0, 0xe6,
0x73, 0x26, 0xb7, 0x76, 0x59, 0xfa, 0x5b, 0x60, 0xc6, 0x41, 0x84, 0xbe, 0x64, 0x6b, 0xd4, 0xe6,
0xfa, 0x00, 0x7e, 0x6d, 0xdc, 0xe3, 0xfe, 0x43, 0xb7, 0xdb, 0xed, 0x7a, 0x57, 0xb3, 0xe2, 0x88,
0xad, 0x91, 0xb4, 0x01, 0xb4, 0x50, 0x89, 0x19, 0xf2, 0x46, 0x4d, 0x8f, 0x31, 0x3f, 0x7f, 0x73,
0xaf, 0x68, 0xa5, 0xa7, 0xbb, 0x8c, 0xb3, 0x9a, 0xfd, 0xde, 0x80, 0xd3, 0x9d, 0x59, 0x32, 0x16,
0x5c, 0x22, 0x79, 0x04, 0xb0, 0x85, 0x95, 0x0d, 0xe3, 0xa2, 0xde, 0xbe, 0xd6, 0xbb, 0xed, 0x54,
0xac, 0xd5, 0xd9, 0x1e, 0xd5, 0x2c, 0xcf, 0x21, 0x49, 0x13, 0x4e, 0x38, 0x2e, 0x95, 0xbf, 0x8b,
0xe2, 0xdd, 0xc8, 0x7e, 0xbf, 0x28, 0x19, 0x7a, 0x5f, 0x6b, 0x70, 0x52, 0xfa, 0x47, 0x79, 0x8a,
0xe4, 0xa3, 0x01, 0xf5, 0x21, 0x2a, 0x72, 0xb7, 0x72, 0xe2, 0xff, 0xfb, 0xb5, 0x0e, 0xe3, 0xd9,
0xf7, 0x3e, 0x7c, 0xff, 0xf1, 0xa5, 0xd6, 0x24, 0x77, 0x76, 0xc3, 0xd5, 0xc8, 0xf4, 0xed, 0xdf,
0xf9, 0xbc, 0x23, 0x9f, 0x0c, 0x38, 0xca, 0xb6, 0x43, 0x3a, 0x95, 0x9d, 0xf7, 0x05, 0x65, 0x39,
0x97, 0x95, 0xe7, 0xbb, 0xb6, 0xcf, 0x35, 0xd5, 0x19, 0x39, 0xdd, 0x4b, 0x35, 0x78, 0xfa, 0xf2,
0x71, 0xc4, 0xd4, 0xab, 0x64, 0x92, 0x75, 0x2a, 0x9e, 0x42, 0x27, 0xbf, 0x79, 0x91, 0xe8, 0x44,
0xc8, 0xf5, 0xa5, 0xab, 0x7a, 0x23, 0x0f, 0x8a, 0xcf, 0xc9, 0xb1, 0x96, 0xdd, 0xff, 0x1d, 0x00,
0x00, 0xff, 0xff, 0xf1, 0x82, 0x37, 0x5b, 0x4d, 0x03, 0x00, 0x00,
// 436 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x8c, 0x53, 0xcf, 0x8b, 0xd3, 0x40,
0x14, 0x26, 0xed, 0xba, 0x98, 0xa7, 0xb2, 0x30, 0xb8, 0x6c, 0x89, 0x2e, 0xac, 0x41, 0xba, 0x05,
0x6d, 0xa6, 0x59, 0x8f, 0xae, 0x20, 0x55, 0x58, 0x04, 0x0f, 0x92, 0xdd, 0x93, 0x97, 0x90, 0x36,
0x8f, 0x38, 0xb4, 0xce, 0x8c, 0x3b, 0x93, 0xd0, 0x56, 0x3c, 0xf8, 0xe3, 0xe4, 0xd5, 0xbb, 0xff,
0x4e, 0xbd, 0xfb, 0x2f, 0x78, 0xf0, 0x6f, 0xf0, 0x24, 0x99, 0x24, 0xb5, 0xad, 0x0d, 0xdd, 0xdb,
0x30, 0xef, 0xfb, 0xbe, 0xf7, 0xcd, 0xfb, 0xe6, 0x01, 0x9d, 0x46, 0x3c, 0xc6, 0x09, 0x1d, 0x8e,
0x45, 0x1a, 0xd3, 0xa1, 0x78, 0x2b, 0x53, 0x8d, 0x34, 0xf3, 0x69, 0xcc, 0xd4, 0x28, 0xd4, 0x53,
0x89, 0xa1, 0xc2, 0xcb, 0x8c, 0x0d, 0xd1, 0x93, 0x97, 0x42, 0x0b, 0x72, 0x50, 0x10, 0x3c, 0x43,
0xf0, 0x4a, 0x82, 0x97, 0xf9, 0xce, 0xdd, 0x44, 0x88, 0x64, 0x8c, 0x34, 0x92, 0x8c, 0x46, 0x9c,
0x0b, 0x1d, 0x69, 0x26, 0xb8, 0x2a, 0x68, 0xce, 0xf1, 0xd6, 0x3e, 0x25, 0xf0, 0x70, 0x05, 0x98,
0x45, 0x63, 0x16, 0x1b, 0xa1, 0xa2, 0xec, 0x9e, 0x02, 0x39, 0x43, 0xfd, 0x9c, 0xa9, 0xd1, 0xc5,
0x54, 0x62, 0x80, 0xef, 0x52, 0x54, 0x9a, 0xb4, 0xe1, 0xe6, 0x3f, 0xbf, 0x2c, 0x6e, 0x59, 0x47,
0x56, 0xc7, 0xee, 0xef, 0xfc, 0x9e, 0xfb, 0x56, 0x00, 0x71, 0x09, 0x7e, 0x11, 0xbb, 0x0c, 0x6e,
0xbf, 0x64, 0x6a, 0x41, 0x57, 0x15, 0xff, 0x18, 0x6c, 0x19, 0x25, 0x18, 0x2a, 0x36, 0x43, 0x43,
0x6e, 0xf6, 0xe1, 0xcf, 0xdc, 0xdf, 0x3d, 0x7d, 0xe2, 0xf7, 0x7a, 0xbd, 0xe0, 0x7a, 0x5e, 0x3c,
0x67, 0x33, 0x24, 0x1d, 0x00, 0x03, 0xd4, 0x62, 0x84, 0xbc, 0xd5, 0x30, 0x6d, 0xec, 0xaf, 0x3f,
0xfc, 0x6b, 0x06, 0x19, 0x18, 0x95, 0x8b, 0xbc, 0xe6, 0x7e, 0xb4, 0x60, 0x7f, 0xad, 0x97, 0x92,
0x82, 0x2b, 0x24, 0x4f, 0x01, 0x16, 0x66, 0x55, 0xcb, 0x3a, 0x6a, 0x76, 0x6e, 0x9c, 0xdc, 0xf3,
0x6a, 0xc6, 0xea, 0x2d, 0x9e, 0x6a, 0x57, 0xef, 0x50, 0xa4, 0x0d, 0x7b, 0x1c, 0x27, 0x3a, 0x5c,
0xb7, 0x12, 0xdc, 0xca, 0xaf, 0x5f, 0x55, 0x1e, 0x4e, 0xbe, 0x37, 0x60, 0xaf, 0xe2, 0x9f, 0x17,
0x29, 0x92, 0xcf, 0x16, 0x34, 0xcf, 0x50, 0x93, 0x07, 0xb5, 0x1d, 0xff, 0x9f, 0xaf, 0xb3, 0xdd,
0x9e, 0xfb, 0xf0, 0xd3, 0xcf, 0x5f, 0xdf, 0x1a, 0x6d, 0x72, 0x7f, 0x3d, 0x5c, 0x63, 0x99, 0xbe,
0x5f, 0xce, 0xe7, 0x03, 0xf9, 0x62, 0xc1, 0x4e, 0x3e, 0x1d, 0xd2, 0xad, 0x55, 0xde, 0x14, 0x94,
0xe3, 0x5d, 0x15, 0x5e, 0xcc, 0xda, 0x3d, 0x34, 0xae, 0x0e, 0xc8, 0xfe, 0x46, 0x57, 0xfd, 0x01,
0xdc, 0x59, 0xd1, 0x8b, 0x24, 0x5b, 0xd2, 0x7c, 0xfd, 0x2c, 0x61, 0xfa, 0x4d, 0x3a, 0xc8, 0xaf,
0xca, 0x3d, 0xe9, 0x16, 0xdf, 0x32, 0x11, 0xdd, 0x04, 0xb9, 0xf9, 0x91, 0x75, 0x0b, 0xf4, 0xb8,
0x3c, 0x0e, 0x76, 0x0d, 0xec, 0xd1, 0xdf, 0x00, 0x00, 0x00, 0xff, 0xff, 0x68, 0xcb, 0xd9, 0xc1,
0x6a, 0x03, 0x00, 0x00,
}
// Reference imports to suppress errors if they are not otherwise used.
var _ context.Context
var _ grpc.ClientConn
var _ grpc.ClientConnInterface
// This is a compile-time assertion to ensure that this generated file
// is compatible with the grpc package it is being compiled against.
const _ = grpc.SupportPackageIsVersion4
const _ = grpc.SupportPackageIsVersion6
// DiskTypeServiceClient is the client API for DiskTypeService service.
//
@ -236,10 +237,10 @@ type DiskTypeServiceClient interface {
}
type diskTypeServiceClient struct {
cc *grpc.ClientConn
cc grpc.ClientConnInterface
}
func NewDiskTypeServiceClient(cc *grpc.ClientConn) DiskTypeServiceClient {
func NewDiskTypeServiceClient(cc grpc.ClientConnInterface) DiskTypeServiceClient {
return &diskTypeServiceClient{cc}
}

23
vendor/github.com/yandex-cloud/go-genproto/yandex/cloud/compute/v1/disk_type_service.pbext.go generated vendored Normal file
View file

@ -0,0 +1,23 @@
// Code generated by protoc-gen-goext. DO NOT EDIT.
package compute
func (m *GetDiskTypeRequest) SetDiskTypeId(v string) {
m.DiskTypeId = v
}
func (m *ListDiskTypesRequest) SetPageSize(v int64) {
m.PageSize = v
}
func (m *ListDiskTypesRequest) SetPageToken(v string) {
m.PageToken = v
}
func (m *ListDiskTypesResponse) SetDiskTypes(v []*DiskType) {
m.DiskTypes = v
}
func (m *ListDiskTypesResponse) SetNextPageToken(v string) {
m.NextPageToken = v
}

73
vendor/github.com/yandex-cloud/go-genproto/yandex/cloud/compute/v1/image.pb.go generated vendored
View file

@ -294,40 +294,41 @@ func init() {
}
var fileDescriptor_c226a196eae12730 = []byte{
// 555 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x84, 0x93, 0xdf, 0x6b, 0x9c, 0x40,
0x10, 0xc7, 0xab, 0xf7, 0x23, 0x71, 0x4c, 0x83, 0x2c, 0x21, 0x95, 0xe4, 0x21, 0xf6, 0x4a, 0xe1,
0x68, 0x89, 0x92, 0x6b, 0x1e, 0x9a, 0x96, 0x3e, 0x5c, 0x72, 0xb6, 0x08, 0xe1, 0x2e, 0xec, 0x19,
0xd2, 0xf4, 0x45, 0xbc, 0xdb, 0x8d, 0x5d, 0xa2, 0xae, 0xb8, 0x6b, 0xa8, 0xf9, 0x7b, 0xfb, 0x87,
0x14, 0x57, 0x03, 0xa1, 0x70, 0xed, 0xdb, 0xcc, 0xd7, 0xcf, 0xcc, 0x77, 0x67, 0xd7, 0x81, 0x37,
0x75, 0x9c, 0x13, 0xfa, 0xcb, 0x5b, 0xa7, 0xbc, 0x22, 0xde, 0x9a, 0x67, 0x45, 0x25, 0xa9, 0xf7,
0x70, 0xe2, 0xb1, 0x2c, 0x4e, 0xa8, 0x5b, 0x94, 0x5c, 0x72, 0xf4, 0xaa, 0x85, 0x5c, 0x05, 0xb9,
0x1d, 0xe4, 0x3e, 0x9c, 0x1c, 0x1c, 0x25, 0x9c, 0x27, 0x29, 0xf5, 0x14, 0xb6, 0xaa, 0xee, 0x3c,
0xc9, 0x32, 0x2a, 0x64, 0x9c, 0x15, 0x6d, 0xe5, 0xe8, 0x77, 0x1f, 0x06, 0x41, 0xd3, 0x09, 0xed,
0x82, 0xce, 0x88, 0xad, 0x39, 0xda, 0xd8, 0xc0, 0x3a, 0x23, 0xe8, 0x10, 0x8c, 0x3b, 0x9e, 0x12,
0x5a, 0x46, 0x8c, 0xd8, 0xba, 0x92, 0xb7, 0x5b, 0x21, 0x20, 0xe8, 0x0c, 0x60, 0x5d, 0xd2, 0x58,
0x52, 0x12, 0xc5, 0xd2, 0xee, 0x39, 0xda, 0xd8, 0x9c, 0x1c, 0xb8, 0xad, 0x99, 0xfb, 0x64, 0xe6,
0x86, 0x4f, 0x66, 0xd8, 0xe8, 0xe8, 0xa9, 0x44, 0x08, 0xfa, 0x79, 0x9c, 0x51, 0xbb, 0xaf, 0x5a,
0xaa, 0x18, 0x39, 0x60, 0x12, 0x2a, 0xd6, 0x25, 0x2b, 0x24, 0xe3, 0xb9, 0x3d, 0x50, 0x9f, 0x9e,
0x4b, 0xe8, 0x1c, 0x86, 0x69, 0xbc, 0xa2, 0xa9, 0xb0, 0x87, 0x4e, 0x6f, 0x6c, 0x4e, 0xde, 0xb9,
0x1b, 0x46, 0x76, 0xd5, 0x34, 0xee, 0xa5, 0x82, 0xfd, 0x5c, 0x96, 0x35, 0xee, 0x2a, 0xd1, 0x3e,
0x0c, 0xef, 0xe2, 0x8c, 0xa5, 0xb5, 0xbd, 0xa5, 0x0c, 0xba, 0x0c, 0xbd, 0x86, 0x1d, 0x21, 0x79,
0x19, 0x27, 0x34, 0x12, 0xec, 0x91, 0xda, 0xdb, 0x8e, 0x36, 0xee, 0x61, 0xb3, 0xd3, 0x96, 0xec,
0x91, 0xa2, 0x11, 0xbc, 0xcc, 0x58, 0x1e, 0x11, 0x26, 0xee, 0x5b, 0xc6, 0x68, 0x99, 0x8c, 0xe5,
0x33, 0x26, 0xee, 0x15, 0x73, 0x04, 0x66, 0x51, 0x72, 0x52, 0xad, 0x65, 0xc4, 0x88, 0xb0, 0xc1,
0xe9, 0x8d, 0x0d, 0x0c, 0x9d, 0x14, 0x10, 0x81, 0xbe, 0xc0, 0x50, 0xc8, 0x58, 0x56, 0xc2, 0x36,
0x1d, 0x6d, 0xbc, 0x3b, 0x79, 0xfb, 0x9f, 0x19, 0x96, 0x0a, 0xc6, 0x5d, 0x11, 0x7a, 0x0f, 0x3a,
0x17, 0xf6, 0x8e, 0xba, 0xeb, 0xc3, 0x8d, 0xa5, 0x0b, 0x81, 0x75, 0x2e, 0x0e, 0xce, 0xc0, 0x7c,
0x76, 0x05, 0xc8, 0x82, 0xde, 0x3d, 0xad, 0xbb, 0xd7, 0x6d, 0x42, 0xb4, 0x07, 0x83, 0x87, 0x38,
0xad, 0x68, 0xf7, 0xb4, 0x6d, 0xf2, 0x49, 0xff, 0xa8, 0x8d, 0x30, 0x0c, 0x5b, 0x67, 0xb4, 0x0f,
0x68, 0x19, 0x4e, 0xc3, 0xeb, 0x65, 0x74, 0x3d, 0x5f, 0x5e, 0xf9, 0x17, 0xc1, 0xd7, 0xc0, 0x9f,
0x59, 0x2f, 0xd0, 0x0e, 0x6c, 0x5f, 0x60, 0x7f, 0x1a, 0x06, 0xf3, 0x6f, 0x96, 0x86, 0x0c, 0x18,
0x60, 0x7f, 0x3a, 0xbb, 0xb5, 0xf4, 0x26, 0xf4, 0x31, 0x5e, 0x60, 0xab, 0xd7, 0x30, 0x33, 0xff,
0xd2, 0x57, 0x4c, 0x7f, 0x54, 0x80, 0xbe, 0x10, 0xe8, 0x14, 0xfa, 0xb2, 0x2e, 0xa8, 0x3a, 0xc6,
0xee, 0xc4, 0xf9, 0xc7, 0x0c, 0x6e, 0x58, 0x17, 0x14, 0x2b, 0x7a, 0x74, 0x0a, 0xfd, 0x26, 0x43,
0x7b, 0x60, 0x85, 0xb7, 0x57, 0xfe, 0x5f, 0x67, 0x31, 0x60, 0x70, 0x19, 0xcc, 0xaf, 0xbf, 0x5b,
0x1a, 0x32, 0x61, 0xeb, 0x26, 0x98, 0xcf, 0x16, 0x37, 0x4b, 0x4b, 0x3f, 0xf7, 0x7f, 0x5c, 0x24,
0x4c, 0xfe, 0xac, 0x56, 0x4d, 0x63, 0xaf, 0x75, 0x3a, 0x6e, 0x97, 0x28, 0xe1, 0xc7, 0x09, 0xcd,
0xd5, 0x5f, 0xea, 0x6d, 0xd8, 0xae, 0xcf, 0x5d, 0xb8, 0x1a, 0x2a, 0xec, 0xc3, 0x9f, 0x00, 0x00,
0x00, 0xff, 0xff, 0xee, 0xdc, 0xf1, 0x6f, 0x87, 0x03, 0x00, 0x00,
// 564 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x84, 0x93, 0x5f, 0x6b, 0xdb, 0x3c,
0x14, 0xc6, 0x5f, 0x3b, 0x7f, 0x5a, 0x1f, 0xf7, 0x2d, 0x46, 0x94, 0xce, 0xb4, 0x17, 0xf5, 0x32,
0x06, 0x61, 0xa3, 0x36, 0xcd, 0x7a, 0xb1, 0x6e, 0xec, 0x22, 0x6d, 0xbc, 0x61, 0x28, 0x49, 0x51,
0x52, 0xba, 0xee, 0x26, 0x28, 0x91, 0xea, 0x89, 0xda, 0x96, 0xb1, 0xe4, 0x32, 0xf7, 0xf3, 0xee,
0x83, 0x0c, 0xcb, 0x2e, 0x74, 0x83, 0x6c, 0x77, 0xe7, 0x3c, 0xfe, 0x9d, 0xf3, 0xe8, 0x48, 0x3e,
0xf0, 0xaa, 0x22, 0x19, 0x65, 0x3f, 0x82, 0x75, 0x22, 0x4a, 0x1a, 0xac, 0x45, 0x9a, 0x97, 0x8a,
0x05, 0x0f, 0x27, 0x01, 0x4f, 0x49, 0xcc, 0xfc, 0xbc, 0x10, 0x4a, 0xa0, 0x17, 0x0d, 0xe4, 0x6b,
0xc8, 0x6f, 0x21, 0xff, 0xe1, 0xe4, 0xe0, 0x28, 0x16, 0x22, 0x4e, 0x58, 0xa0, 0xb1, 0x55, 0x79,
0x17, 0x28, 0x9e, 0x32, 0xa9, 0x48, 0x9a, 0x37, 0x95, 0x83, 0x9f, 0x5d, 0xe8, 0x45, 0x75, 0x27,
0xb4, 0x0b, 0x26, 0xa7, 0xae, 0xe1, 0x19, 0x43, 0x0b, 0x9b, 0x9c, 0xa2, 0x43, 0xb0, 0xee, 0x44,
0x42, 0x59, 0xb1, 0xe4, 0xd4, 0x35, 0xb5, 0xbc, 0xdd, 0x08, 0x11, 0x45, 0x67, 0x00, 0xeb, 0x82,
0x11, 0xc5, 0xe8, 0x92, 0x28, 0xb7, 0xe3, 0x19, 0x43, 0x7b, 0x74, 0xe0, 0x37, 0x66, 0xfe, 0x93,
0x99, 0xbf, 0x78, 0x32, 0xc3, 0x56, 0x4b, 0x8f, 0x15, 0x42, 0xd0, 0xcd, 0x48, 0xca, 0xdc, 0xae,
0x6e, 0xa9, 0x63, 0xe4, 0x81, 0x4d, 0x99, 0x5c, 0x17, 0x3c, 0x57, 0x5c, 0x64, 0x6e, 0x4f, 0x7f,
0x7a, 0x2e, 0xa1, 0x73, 0xe8, 0x27, 0x64, 0xc5, 0x12, 0xe9, 0xf6, 0xbd, 0xce, 0xd0, 0x1e, 0xbd,
0xf1, 0x37, 0x8c, 0xec, 0xeb, 0x69, 0xfc, 0x4b, 0x0d, 0x87, 0x99, 0x2a, 0x2a, 0xdc, 0x56, 0xa2,
0x7d, 0xe8, 0xdf, 0x91, 0x94, 0x27, 0x95, 0xbb, 0xa5, 0x0d, 0xda, 0x0c, 0xbd, 0x84, 0x1d, 0xa9,
0x44, 0x41, 0x62, 0xb6, 0x94, 0xfc, 0x91, 0xb9, 0xdb, 0x9e, 0x31, 0xec, 0x60, 0xbb, 0xd5, 0xe6,
0xfc, 0x91, 0xa1, 0x01, 0xfc, 0x9f, 0xf2, 0x6c, 0x49, 0xb9, 0xbc, 0x6f, 0x18, 0xab, 0x61, 0x52,
0x9e, 0x4d, 0xb8, 0xbc, 0xd7, 0xcc, 0x11, 0xd8, 0x79, 0x21, 0x68, 0xb9, 0x56, 0x4b, 0x4e, 0xa5,
0x0b, 0x5e, 0x67, 0x68, 0x61, 0x68, 0xa5, 0x88, 0x4a, 0xf4, 0x09, 0xfa, 0x52, 0x11, 0x55, 0x4a,
0xd7, 0xf6, 0x8c, 0xe1, 0xee, 0xe8, 0xf5, 0x3f, 0x66, 0x98, 0x6b, 0x18, 0xb7, 0x45, 0xe8, 0x2d,
0x98, 0x42, 0xba, 0x3b, 0xfa, 0xae, 0x0f, 0x37, 0x96, 0xce, 0x24, 0x36, 0x85, 0x3c, 0x38, 0x03,
0xfb, 0xd9, 0x15, 0x20, 0x07, 0x3a, 0xf7, 0xac, 0x6a, 0x5f, 0xb7, 0x0e, 0xd1, 0x1e, 0xf4, 0x1e,
0x48, 0x52, 0xb2, 0xf6, 0x69, 0x9b, 0xe4, 0x83, 0xf9, 0xde, 0x18, 0x60, 0xe8, 0x37, 0xce, 0x68,
0x1f, 0xd0, 0x7c, 0x31, 0x5e, 0x5c, 0xcf, 0x97, 0xd7, 0xd3, 0xf9, 0x55, 0x78, 0x11, 0x7d, 0x8e,
0xc2, 0x89, 0xf3, 0x1f, 0xda, 0x81, 0xed, 0x0b, 0x1c, 0x8e, 0x17, 0xd1, 0xf4, 0x8b, 0x63, 0x20,
0x0b, 0x7a, 0x38, 0x1c, 0x4f, 0x6e, 0x1d, 0xb3, 0x0e, 0x43, 0x8c, 0x67, 0xd8, 0xe9, 0xd4, 0xcc,
0x24, 0xbc, 0x0c, 0x35, 0xd3, 0x1d, 0xe4, 0x60, 0xce, 0x24, 0x3a, 0x85, 0xae, 0xaa, 0x72, 0xa6,
0x8f, 0xb1, 0x3b, 0xf2, 0xfe, 0x32, 0x83, 0xbf, 0xa8, 0x72, 0x86, 0x35, 0x3d, 0x38, 0x85, 0x6e,
0x9d, 0xa1, 0x3d, 0x70, 0x16, 0xb7, 0x57, 0xe1, 0x1f, 0x67, 0xb1, 0xa0, 0x77, 0x19, 0x4d, 0xaf,
0xbf, 0x3a, 0x06, 0xb2, 0x61, 0xeb, 0x26, 0x9a, 0x4e, 0x66, 0x37, 0x73, 0xc7, 0x3c, 0x5f, 0xc1,
0xe1, 0x6f, 0xed, 0x49, 0xce, 0x9f, 0x59, 0x7c, 0xbb, 0x88, 0xb9, 0xfa, 0x5e, 0xae, 0x6a, 0x29,
0x68, 0xb8, 0xe3, 0x66, 0xc3, 0x62, 0x71, 0x1c, 0xb3, 0x4c, 0xff, 0xc2, 0xc1, 0x86, 0xd5, 0xfb,
0xd8, 0x86, 0xab, 0xbe, 0xc6, 0xde, 0xfd, 0x0a, 0x00, 0x00, 0xff, 0xff, 0xea, 0x21, 0x47, 0xea,
0xa4, 0x03, 0x00, 0x00,
}

Some files were not shown because too many files have changed in this diff Show more